文档菜单
文档首页
/
MongoDB 手册
/
CRUD 操作

删除文档

在本页

  • 删除所有文档
  • 删除满足条件的所有文档
  • 删除满足条件的一个文档
  • 使用 MongoDB Atlas 删除文档
  • 删除行为

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

  • 您编程语言的驱动程序。

  • 使用MongoDB Atlas UI. 要了解详细信息，请参阅 使用 MongoDB Atlas 删除文档.

  • MongoDB Compass.

➤使用右上角的 选择您的语言 下拉菜单设置以下示例或 MongoDB Compass 的语言。

本页面使用以下mongosh方法

  • db.collection.deleteMany()

  • db.collection.deleteOne()

本页面的示例使用inventory集合。要填充inventory集合，请运行以下

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

使用以下文档填充inventory集合

本页面使用以下MongoDB C Driver方法

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

本页面使用以下MongoDB C# Driver方法

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

本页面使用以下MongoDB Go Driver函数

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

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

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

本页面使用以下 Java 同步驱动 方法

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

本页面使用以下 Kotlin 协程驱动 方法

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

本页面使用以下 Motor 驱动方法

本页面的示例使用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 Driver方法

本页面的示例使用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 返回一个类型为 Publisher 的对象，如果成功。如果失败，则返回 com.mongodb.MongoException 的实例。

方法 MongoCollection.deleteMany() 返回一个 com.mongodb.client.result.DeleteResult 实例，描述了操作的状态和删除的文档数量。

异步协程函数 delete_many 返回一个包含操作状态的 pymongo.results.DeleteResult 实例。

deleteMany() 返回一个包含结果的承诺。属性 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()方法返回一个包含单个元素（元素类型为DeleteResult或com.mongodb.MongoException）的Observable。

删除符合条件的所有文档

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有匹配删除条件的文档，将一个过滤器参数传递给deleteMany()方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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>);

为了指定相等条件，请使用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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，请将一个 过滤器 参数传递给 IMongoCollection.DeleteMany() 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，请将一个 过滤器 参数传递给 Collection.DeleteMany 函数。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，请将一个 过滤器 参数传递给 com.mongodb.client.MongoCollection.deleteMany 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，请将一个 过滤器 参数传递给 MongoCollection.deleteMany() 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有匹配删除标准的文档，请将过滤器参数传递给delete_many方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有匹配删除标准的文档，请将过滤器参数传递给deleteMany()方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有匹配删除标准的文档，请将过滤器参数传递给delete_many()方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有匹配删除标准的文档，请将过滤器参数传递给deleteMany()方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，将一个 过滤器 参数传递给 delete_many 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，将一个 过滤器 参数传递给 delete_many() 方法。

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

您可以为要删除的文档指定标准或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤器文档中使用<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>) ...)

查询过滤器文档可以使用查询操作符以以下形式指定条件：

{ <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还提供了各种查询运算符来指定过滤条件。使用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> }, ... }

查询过滤器文档可以使用查询操作符以以下形式指定条件：

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

除了等式条件之外，MongoDB还提供了各种查询运算符来指定过滤条件。使用com.mongodb.client.model.Filters_辅助方法来简化过滤文档的创建。例如

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

要删除所有符合删除标准的文档，将一个 过滤器 参数传递给 deleteMany() 方法。

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

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 返回一个类型为 Publisher 的对象，如果成功。如果失败，则返回 com.mongodb.MongoException 的实例。

方法 MongoCollection.deleteMany() 返回一个 com.mongodb.client.result.DeleteResult 实例，描述了操作的状态和删除的文档数量。

异步协程函数 delete_many 返回一个包含操作状态的 pymongo.results.DeleteResult 实例。

deleteMany() 返回一个包含结果的承诺。属性 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()方法返回一个包含单个元素（元素类型为DeleteResult或com.mongodb.MongoException）的Observable。

只删除一个符合条件文档

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

以下示例删除第一个状态为 "D" 的文档。

MongoDB Compass 提供了一种简单的方法来从集合中删除文档。以下示例展示了如何从 inventory 集合中删除 item 等于 paper 的文档。

注意

在这个示例中，我们使用 Compass 的 表格视图 来删除文档。使用 Compass 的 列表视图 删除文档的过程非常相似。

有关 Compass 中表格视图和列表视图之间差异的更多信息，请参阅 Compass 文档。

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

以下示例删除了inventory集合中的所有文档

要删除最多一个与指定过滤器匹配的文档（尽管可能有多个文档与指定过滤器匹配），请使用IMongoCollection.DeleteOne()方法。

以下示例删除第一个状态为 "D" 的文档。

要删除最多一个与指定过滤器匹配的文档（尽管可能有多个文档与指定过滤器匹配），请使用Collection.DeleteOne函数。

以下示例删除第一个状态为 "D" 的文档。

要删除最多一个与指定过滤器匹配的文档（尽管可能有多个文档与指定过滤器匹配），请使用com.mongodb.reactivestreams.client.MongoCollection.deleteMany方法。

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

要删除最多一个与指定过滤器匹配的文档（即使可能有多个文档与指定过滤器匹配），请使用 motor.motor_asyncio.AsyncIOMotorCollection.delete_one 方法。

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

要删除最多一个匹配指定过滤器的文档（即使可能有多个文档匹配指定过滤器），请使用 MongoDB\\Collection::deleteOne() 方法。

以下示例删除第一个状态为 "D" 的文档。

要删除最多一个与指定过滤器匹配的文档（即使可能有多个文档与指定过滤器匹配），请使用pymongo.collection.Collection.delete_one方法。

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

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

以下示例删除第一个状态为 "D" 的文档。

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

  1. 点击表格按钮，进入表格视图：

    Compass Table View button

  2. 使用Compass的查询栏定位目标文档。

    将以下过滤器文档复制到查询栏，并点击查找

    { item: "paper" }
    Compass Find button

  3. 将鼠标悬停在文档上，然后点击右侧出现的垃圾桶图标

    Compass Delete Document button

    点击删除按钮后，文档将被标记为删除，Compass会询问您是否确实想删除文档

    Compass Confirm Deletion button

  4. 点击删除以确认。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"));
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 UI中，您一次只能删除一个文档。要删除多个文档，请从mongosh或MongoDB驱动程序连接到您的Atlas部署，并按照此页上的示例使用您首选的方法。

本节中的示例使用电影样本数据集。要了解如何将样本数据集加载到您的MongoDB Atlas部署中，请参阅加载样本数据。

要在MongoDB Atlas中删除文档，请按照以下步骤操作

1

在MongoDB Atlas UI中，转到您的项目的集群页面。

  1. 如果它尚未显示，请从导航栏中的 组织菜单中选择包含您的目标项目的组织。

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

  3. 如果它尚未显示，请点击侧边栏中的集群。

    显示 集群 页面。

2

导航到集合。

  1. 对于包含样本数据的集群，点击 浏览集合。

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

  3. 选择 movies 集合。

3

指定查询过滤器文档。

可选地，您可以在 过滤器 字段中指定一个 查询过滤器文档。查询过滤器文档使用 查询运算符 指定搜索条件。

将以下查询过滤器文档复制到 过滤器 搜索栏中，并点击 应用

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

此查询过滤器返回 sample_mflix.movies 集合中所有 genres 等于 Action 且 rated 等于 PG 或 PG-13 的文档。

4

删除文档。

  1. 对于要删除的文档，将鼠标悬停在文档上，然后点击右侧出现的垃圾桶图标。

    点击删除按钮后，MongoDB Atlas会将文档标记为删除并要求您确认。

  2. 点击删除以确认您的选择。

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

删除行为

索引

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

原子性

MongoDB中所有对单个文档的写操作都是原子的。有关MongoDB和原子性的更多信息，请参阅原子性和事务。

编写确认

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

提示

另请参阅

返回

方法

下一页

方法