Docs 菜单
Docs 主页
/
MongoDB Manual
/

Delete Documents

在此页面上

  • 删除所有文档
  • 删除符合条件的所有文档
  • 仅删除一个符合条件的文档
  • 使用 MongoDB Atlas 删除文档
  • 删除行为

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

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

  • MongoDB Atlas 用户界面。要了解更多信息,请参阅使用 MongoDB Atlas 删除文档

  • MongoDB Compass。


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


本页面使用以下 mongosh 方法:

  • db.collection.deleteMany()

  • db.collection.deleteOne()

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

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

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

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

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

此页面使用以下 MongoDB 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 集合:

此页面使用以下 MongoDB Node.js 驱动程序 方法:

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

此页面使用以下 MongoDB Perl 驱动程序 方法:

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

本页面使用以下 MongoDB PHP 库方法:

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

本页面使用以下 PyMongo Python 驱动方法:

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

此页面使用以下 MongoDB Ruby 驱动程序方法:

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

此页面使用以下 MongoDB Scala 驱动程序 方法:

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

db.inventory.insertMany( [
{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
] );
[
{ "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
{ "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" },
{ "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
{ "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
{ "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

有关在 MongoDB Compass 中插入文档的说明,请参阅插入文档

注意

有关在 MongoDB Compass 中插入文档的完整参考信息,请参阅 Compass 文档

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
"item", BCON_UTF8 ("journal"),
"qty", BCON_INT64 (25),
"size", "{",
"h", BCON_DOUBLE (14),
"w", BCON_DOUBLE (21),
"uom", BCON_UTF8 ("cm"),
"}",
"status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
doc = BCON_NEW (
"item", BCON_UTF8 ("notebook"),
"qty", BCON_INT64 (50),
"size", "{",
"h", BCON_DOUBLE (8.5),
"w", BCON_DOUBLE (11),
"uom", BCON_UTF8 ("in"),
"}",
"status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
doc = BCON_NEW (
"item", BCON_UTF8 ("paper"),
"qty", BCON_INT64 (100),
"size", "{",
"h", BCON_DOUBLE (8.5),
"w", BCON_DOUBLE (11),
"uom", BCON_UTF8 ("in"),
"}",
"status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
doc = BCON_NEW (
"item", BCON_UTF8 ("planner"),
"qty", BCON_INT64 (75),
"size", "{",
"h", BCON_DOUBLE (22.85),
"w", BCON_DOUBLE (30),
"uom", BCON_UTF8 ("cm"),
"}",
"status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
doc = BCON_NEW (
"item", BCON_UTF8 ("postcard"),
"qty", BCON_INT64 (45),
"size", "{",
"h", BCON_DOUBLE (10),
"w", BCON_DOUBLE (15.25),
"uom", BCON_UTF8 ("cm"),
"}",
"status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
}
var documents = new[]
{
new BsonDocument
{
{ "item", "journal" },
{ "qty", 25 },
{ "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
{ "status", "A" }
},
new BsonDocument
{
{ "item", "notebook" },
{ "qty", 50 },
{ "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
{ "status", "P" }
},
new BsonDocument
{
{ "item", "paper" },
{ "qty", 100 },
{ "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
{ "status", "D" }
},
new BsonDocument
{
{ "item", "planner" },
{ "qty", 75 },
{ "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
{ "status", "D" }
},
new BsonDocument
{
{ "item", "postcard" },
{ "qty", 45 },
{ "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
{ "status", "A" }
}
};
collection.InsertMany(documents);
docs := []interface{}{
bson.D{
{"item", "journal"},
{"qty", 25},
{"size", bson.D{
{"h", 14},
{"w", 21},
{"uom", "cm"},
}},
{"status", "A"},
},
bson.D{
{"item", "notebook"},
{"qty", 50},
{"size", bson.D{
{"h", 8.5},
{"w", 11},
{"uom", "in"},
}},
{"status", "P"},
},
bson.D{
{"item", "paper"},
{"qty", 100},
{"size", bson.D{
{"h", 8.5},
{"w", 11},
{"uom", "in"},
}},
{"status", "D"},
},
bson.D{
{"item", "planner"},
{"qty", 75},
{"size", bson.D{
{"h", 22.85},
{"w", 30},
{"uom", "cm"},
}},
{"status", "D"},
},
bson.D{
{"item", "postcard"},
{"qty", 45},
{"size", bson.D{
{"h", 10},
{"w", 15.25},
{"uom", "cm"},
}},
{"status", "A"},
},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(asList(
Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(
listOf(
Document("item", "journal")
.append("qty", 25)
.append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
.append("status", "A"),
Document("item", "notebook")
.append("qty", 50)
.append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
.append("status", "A"),
Document("item", "paper")
.append("qty", 100)
.append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
.append("status", "D"),
Document("item", "planner")
.append("qty", 75)
.append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
.append("status", "D"),
Document("item", "postcard")
.append("qty", 45)
.append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
.append("status", "A"),
)
)
await db.inventory.insert_many(
[
{
"item": "journal",
"qty": 25,
"size": {"h": 14, "w": 21, "uom": "cm"},
"status": "A",
},
{
"item": "notebook",
"qty": 50,
"size": {"h": 8.5, "w": 11, "uom": "in"},
"status": "P",
},
{
"item": "paper",
"qty": 100,
"size": {"h": 8.5, "w": 11, "uom": "in"},
"status": "D",
},
{
"item": "planner",
"qty": 75,
"size": {"h": 22.85, "w": 30, "uom": "cm"},
"status": "D",
},
{
"item": "postcard",
"qty": 45,
"size": {"h": 10, "w": 15.25, "uom": "cm"},
"status": "A",
},
]
)
await db.collection('inventory').insertMany([
{
item: 'journal',
qty: 25,
size: { h: 14, w: 21, uom: 'cm' },
status: 'A'
},
{
item: 'notebook',
qty: 50,
size: { h: 8.5, w: 11, uom: 'in' },
status: 'P'
},
{
item: 'paper',
qty: 100,
size: { h: 8.5, w: 11, uom: 'in' },
status: 'D'
},
{
item: 'planner',
qty: 75,
size: { h: 22.85, w: 30, uom: 'cm' },
status: 'D'
},
{
item: 'postcard',
qty: 45,
size: { h: 10, w: 15.25, uom: 'cm' },
status: 'A'
}
]);
$db->coll("inventory")->insert_many(
[
{
item => "journal",
qty => 25,
size => { h => 14, w => 21, uom => "cm" },
status => "A"
},
{
item => "notebook",
qty => 50,
size => { h => 8.5, w => 11, uom => "in" },
status => "P"
},
{
item => "paper",
qty => 100,
size => { h => 8.5, w => 11, uom => "in" },
status => "D"
},
{
item => "planner",
qty => 75,
size => { h => 22.85, w => 30, uom => "cm" },
status => "D"
},
{
item => "postcard",
qty => 45,
size => { h => 10, w => 15.25, uom => "cm" },
status => "A"
}
]
);
$insertManyResult = $db->inventory->insertMany([
[
'item' => 'journal',
'qty' => 25,
'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
'status' => 'A',
],
[
'item' => 'notebook',
'qty' => 50,
'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
'status' => 'P',
],
[
'item' => 'paper',
'qty' => 100,
'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
'status' => 'D',
],
[
'item' => 'planner',
'qty' => 75,
'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
'status' => 'D',
],
[
'item' => 'postcard',
'qty' => 45,
'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
'status' => 'A',
],
]);
db.inventory.insert_many(
[
{
"item": "journal",
"qty": 25,
"size": {"h": 14, "w": 21, "uom": "cm"},
"status": "A",
},
{
"item": "notebook",
"qty": 50,
"size": {"h": 8.5, "w": 11, "uom": "in"},
"status": "P",
},
{
"item": "paper",
"qty": 100,
"size": {"h": 8.5, "w": 11, "uom": "in"},
"status": "D",
},
{
"item": "planner",
"qty": 75,
"size": {"h": 22.85, "w": 30, "uom": "cm"},
"status": "D",
},
{
"item": "postcard",
"qty": 45,
"size": {"h": 10, "w": 15.25, "uom": "cm"},
"status": "A",
},
]
)
client[:inventory].insert_many([
{ item: 'journal',
qty: 25,
size: { h: 14, w: 21, uom: 'cm' },
status: 'A' },
{ item: 'notebook',
qty: 50,
size: { h: 8.5, w: 11, uom: 'in' },
status: 'P' },
{ item: 'paper',
qty: 100,
size: { h: 8.5, w: 11, uom: 'in' },
status: 'D' },
{ item: 'planner',
qty: 75,
size: { h: 22.85, w: 30, uom: 'cm' },
status: 'D' },
{ item: 'postcard',
qty: 45,
size: { h: 10, w: 15.25, uom: 'cm' },
status: 'A' },
])
collection.insertMany(Seq(
Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

要删除集合中的所有文档,请将空的过滤器文档 {} 传递给 db.collection.deleteMany() 方法。

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

要删除集合中的所有文档,请将 mongoc_collection_t 和一个 bson_t 将所有文档与 mongoc_collection_delete_many 方法。

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

要删除集合中的所有文档,请将一个空的过滤器 Builders<BsonDocument>.Filter.Empty 传递给 IMongoCollection.DeleteMany() 方法。

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

要从集合中删除所有文档,请将空过滤器文档传递给 Collection.DeleteMany 函数。

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

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

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

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

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

要删除集合中的所有文档,请将空Bson 对象作为 过滤 传递给 MongoCollection.deleteMany()方法。

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

要删除集合中的所有文档,请将一个空的过滤器文档 {} 传递给 motor.motor_asyncio.AsyncIOMotorCollection.delete_many 方法。

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

要删除集合中的所有文档,请将一个空的过滤器文档 {} 传递给 Collection.deleteMany() 方法。

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

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

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

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

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

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

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

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

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

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

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

db.inventory.deleteMany({})
mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW (NULL);
r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
MONGOC_ERROR ("%s\n", error.message);
goto done;
}
var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.DeleteMany(filter);
result, err := coll.DeleteMany(context.TODO(), bson.D{})
Publisher<DeleteResult> deleteManyPublisher = collection.deleteMany(new Document());
collection.deleteMany(new Document());
collection.deleteMany(empty())
await db.inventory.delete_many({})
await db.collection('inventory').deleteMany({});
$db->coll("inventory")->delete_many( {} );
$deleteResult = $db->inventory->deleteMany([]);
db.inventory.delete_many({})
client[:inventory].delete_many({})
collection.deleteMany(Document()).execute()

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

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

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

成功执行后,Collection.DeleteMany 函数会返回一个 DeleteResult 实例,其 DeletedCount 属性包含与过滤器匹配的文档数。

如果成功,com.mongodb.reactivestreams.client.MongoCollection.deleteMany 会返回一个类型为 com.mongodb.client.result.DeleteResultPublisher 对象。如果不成功,则返回一个 com.mongodb.MongoException 实例。

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

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

deleteMany() 会返回一个提供 result 的 Promise。result.deletedCount 属性包含与过滤器匹配的文档数。

成功执行后,delete _many() 方法会返回 MongoDB::DeleteResult 的一个实例,其 deleted_count 属性包含匹配过滤器的文档数。

成功执行后,deleteMany() 方法将返回 MongoDB\\DeleteResult 的实例,该实例的 getDeletedCount() 方法返回与过滤器匹配的文档数。

delete_many 方法会返回一个包含操作状态的 pymongo.results.DeleteResult 的实例。

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

成功执行后,collection.deleteMany() 方法返回一个 Observable,其中带有 DeleteResult 类型参数或 com.mongodb.MongoException 的单元素。

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要删除所有符合删除条件的文档,请将 filter 参数传递给 deleteMany() 方法。

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要删除所有符合删除条件的文档,请将 filter 参数传递给 IMongoCollection.DeleteMany() 方法。

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要删除所有符合删除条件的文档,请将 filter 参数传递给 Collection.DeleteMany 函数。

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

要指定相等条件,请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档

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

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

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

要指定相等条件,请使用 Filters.eq()创建查询过滤文档的方法:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

除了相等过滤条件外,MongoDB 还提供各种