查询文档
要查询文档,请指定查询谓词以指示要返回的文档。如果指定空查询谓词 ( { }
),则查询将返回集合中的所有文档。
您可以使用以下方法查询MongoDB中的文档:
您的编程语言的驱动程序。
MongoDB Atlas 用户界面。要了解更多信息,请参阅使用 MongoDB Atlas 查询文档。
➤ 使用右上角的 Select your language(选择语言)下拉菜单,设置以下示例的语言或选择 MongoDB Compass。
本页面提供的示例展示在 mongosh
中使用 db.collection.find()
方法执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
此页面中的示例展示了使用 MongoDB Compass 执行的查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页提供了使用 MongoDB C# 驱动程序 中的 MongoCollection.Find() 方法进行查询操作的示例。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示使用 Collection.Find 函数在 MongoDB Go Driver 中执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示使用 com.mongodb.reactivestreams.client.MongoCollection.find 方法在 MongoDB Java Reactive Streams 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
此页面中的示例展示了使用 MongoDB Java 同步驱动程序中的 com.mongodb.client.MongoCollection.find 方法执行的查询操作。
提示
此驱动程序提供了 com.mongodb.client.model.Filters 辅助方法,以便于创建过滤器文档。此页面中的示例使用这些方法创建过滤器文档。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示了使用 motor.motor_asyncio.AsyncIOMotorCollection.find
方法在 Motor 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示使用 Collection.find()方法在 MongoDB Node.js 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示使用 MongoDB::Collection::find() 方法在 MongoDB Perl 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示在 MongoDB PHP Library 中使用 MongoDB\\Collection::find()
方法执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页提供了在 PyMongo Python 驱动程序中使用 pymongo.collection.Collection.find
方法进行查询操作的示例。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示在 MongoDB Ruby 驱动程序中使用 Mongo::Collection#find() 方法执行查询操作。
此页面上的示例使用的是 inventory
集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory
集合:
本页面提供的示例展示使用 collection.find() 方法在 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: "A" }, { 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": "A" }, { "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 中插入文档的说明,请参阅插入文档。
var documents = new BsonDocument[] { 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", "A" } }, 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", "A"}, }, 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' }") ));
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": "A", }, { "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: 'A' }, { 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 => "A" }, { 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' => 'A', ], [ '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": "A", }, { "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: 'A' }, { 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()
选择集合中的所有文档
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
要选择集合中的所有文档,请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件:
db.inventory.find( {} )
var filter = Builders<BsonDocument>.Filter.Empty; var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{}, )
FindPublisher<Document> findPublisher = collection.find(new Document());
FindIterable<Document> findIterable = collection.find(new Document());
cursor = db.inventory.find({})
const cursor = db.collection('inventory').find({});
$cursor = $db->coll("inventory")->find( {} );
$cursor = $db->inventory->find([]);
cursor = db.inventory.find({})
client[:inventory].find({})
var findObservable = collection.find(Document())
该操作使用 {}
的查询谓词,对应以下 SQL 声明:
SELECT * FROM inventory
有关此方法的语法的更多信息,请参阅 find()
。
有关 MongoDB Compass 查询栏的更多信息,请参阅查询栏。
有关此方法的语法的更多信息,请参阅 Find()。
有关该方法语法的更多信息,请参阅 com.mongodb.reactivestreams.client.MongoCollection.find。
有关此方法的语法的更多信息,请参阅 com.mongodb.client.MongoCollection.find。
要查看 find()
方法支持的选项,请参阅 find()。
有关此方法的语法的更多信息,请参阅 Find()。
有关此方法的语法的更多信息,请参阅 find()
。
有关此方法的语法的更多信息,请参阅 find
。
有关此方法的语法的更多信息,请参阅 Find()。
有关该方法语法的更多信息,请参阅 collection.find()。
指定相等条件
要指定相等条件,请在查询筛选器文档中使用 <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>) ...)
要指定相等条件,请在查询筛选器文档中使用 <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>) ...)
以下示例从 inventory
中选择集合所有 status
等于 "D"
的文档:
db.inventory.find( { status: "D" } )
将以下过滤器复制到 Compass 查询栏中,然后单击 Find:
{ status: "D" }
var filter = Builders<BsonDocument>.Filter.Eq("status", "D"); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"status", "D"}}, )
findPublisher = collection.find(eq("status", "D"));
findIterable = collection.find(eq("status", "D"));
cursor = db.inventory.find({"status": "D"})
const cursor = db.collection('inventory').find({ status: 'D' });
$cursor = $db->coll("inventory")->find( { status => "D" } );
$cursor = $db->inventory->find(['status' => 'D']);
cursor = db.inventory.find({"status": "D"})
client[:inventory].find(status: 'D')
findObservable = collection.find(equal("status", "D"))
该操作使用 { status: "D" }
的查询谓词,对应以下 SQL 声明:
SELECT * FROM inventory WHERE status = "D"
注意
MongoDB Compass 查询栏根据集合文档中的键(包括嵌入式子文档中的键)自动完成当前查询。
使用查询操作符指定条件
除了相等过滤条件外,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>), equal(<field3>, <value3>))
以下示例从 inventory
集合中检索所有文档。其中 status
等于 "A"
或 "D"
:
db.inventory.find( { status: { $in: [ "A", "D" ] } } )
将以下过滤器复制到 Compass 查询栏中,然后单击 Find:
{ status: { $in: [ "A", "D" ] } }
var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}})
findPublisher = collection.find(in("status", "A", "D"));
findIterable = collection.find(in("status", "A", "D"));
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
const cursor = db.collection('inventory').find({ status: { $in: ['A', 'D'] } });
$cursor = $db->coll("inventory")->find( { status => { '$in' => [ "A", "D" ] } } );
$cursor = $db->inventory->find(['status' => ['$in' => ['A', 'D']]]);
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
client[:inventory].find(status: { '$in' => [ 'A', 'D' ]})
findObservable = collection.find(in("status", "A", "D"))
该操作使用 { status: { $in: [ "A", "D" ] } }
的查询谓词,对应以下 SQL 声明:
SELECT * FROM inventory WHERE status in ("A", "D")
有关 MongoDB 查询运算符的完整列表,请参阅查询和投影运算符文档。
指定 AND
条件
复合查询可以为集合文档中的多个字段指定条件。逻辑 AND
连接词隐式地连接复合查询的子句,以便该查询选择集合中与所有条件匹配的文档。
以下示例检索 inventory
集合中 status
等于 "A"
且qty
小于 ($lt
) 30
的所有文档:
db.inventory.find( { status: "A", qty: { $lt: 30 } } )
将以下过滤器复制到 Compass 查询栏中,然后单击 Find:
{ status: "A", qty: { $lt: 30 } }
var builder = Builders<BsonDocument>.Filter; var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"status", "A"}, {"qty", bson.D{{"$lt", 30}}}, })
findPublisher = collection.find(and(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
const cursor = db.collection('inventory').find({ status: 'A', qty: { $lt: 30 } });
$cursor = $db->coll("inventory")->find( { status => "A", qty => { '$lt' => 30 } } );
$cursor = $db->inventory->find([ 'status' => 'A', 'qty' => ['$lt' => 30], ]);
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
client[:inventory].find(status: 'A', qty: { '$lt' => 30 })
findObservable = collection.find(and(equal("status", "A"), lt("qty", 30)))
该操作使用 { status: "A", qty: { $lt: 30 } }
的查询谓词,对应以下 SQL 声明:
SELECT * FROM inventory WHERE status = "A" AND qty < 30
有关其他 MongoDB 比较运算符,请参阅比较运算符。
指定 OR
条件
可以使用 $or
操作符指定复合查询,该复合查询使用逻辑 OR
连接词连接每个每个子句,以便该查询选择集合中至少匹配一个条件的文档。
以下示例检索集合中 status
等于 "A"
或 qty
小于 ($lt
) 30
的所有文档:
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )
将以下过滤器复制到 Compass 查询栏中,然后单击 Find:
{ $or: [ { status: "A" }, { qty: { $lt: 30 } } ] }
var builder = Builders<BsonDocument>.Filter; var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"$or", bson.A{ bson.D{{"status", "A"}}, bson.D{{"qty", bson.D{{"$lt", 30}}}}, }}, })
findPublisher = collection.find(or(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
const cursor = db.collection('inventory').find({ $or: [{ status: 'A' }, { qty: { $lt: 30 } }] });
$cursor = $db->coll("inventory")->find( { '$or' => [ { status => "A" }, { qty => { '$lt' => 30 } } ] } );
$cursor = $db->inventory->find([ '$or' => [ ['status' => 'A'], ['qty' => ['$lt' => 30]], ], ]);
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
client[:inventory].find('$or' => [{ status: 'A' }, { qty: { '$lt' => 30 } } ])
findObservable = collection.find(or(equal("status", "A"), lt("qty", 30)))
该操作使用 { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }
的查询谓词,对应以下 SQL 声明:
SELECT * FROM inventory WHERE status = "A" OR qty < 30
指定 AND
和 OR
条件
在以下示例中,复合查询文档选择集合中 status
等于 "A"
且 qty
小于 ($lt
) 30
或 item
以字符 p
开头的文档:
db.inventory.find( { status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] } )
将以下过滤器复制到 Compass 查询栏中,然后单击 Find:
{ status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] }
var builder = Builders<BsonDocument>.Filter; var filter = builder.And( builder.Eq("status", "A"), builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p")))); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"status", "A"}, {"$or", bson.A{ bson.D{{"qty", bson.D{{"$lt", 30}}}}, bson.D{{"item", bson.Regex{Pattern: "^p", Options: ""}}}, }}, })
findPublisher = collection.find( and(eq("status", "A"), or(lt("qty", 30), regex("item", "^p"))) );
findIterable = collection.find( and(eq("status", "A"), or(lt("qty", 30), regex("item", "^p"))) );
cursor = db.inventory.find( {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]} )
const cursor = db.collection('inventory').find({ status: 'A', $or: [{ qty: { $lt: 30 } }, { item: { $regex: '^p' } }] });
$cursor = $db->coll("inventory")->find( { status => "A", '$or' => [ { qty => { '$lt' => 30 } }, { item => { '$regex' => "^p" } } ] } );
$cursor = $db->inventory->find([ 'status' => 'A', '$or' => [ ['qty' => ['$lt' => 30]], // Alternatively: ['item' => new \MongoDB\BSON\Regex('^p')] ['item' => ['$regex' => '^p']], ], ]);
cursor = db.inventory.find( {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]} )
client[:inventory].find(status: 'A', '$or' => [{ qty: { '$lt' => 30 } }, { item: { '$regex' => BSON::Regexp::Raw.new('^p') } } ])
findObservable = collection.find(and( equal("status", "A"), or(lt("qty", 30), regex("item", "^p"))) )
该操作使用以下查询谓词:
{ status: 'A', $or: [ { qty: { $lt: 30 } }, { item: { $regex: '^p' } } ] }
对应如下 SQL 语句:
SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")
注意
MongoDB 支持正则表达式 $regex
查询,以执行字符串模式匹配。
使用 MongoDB Atlas 查询文档
本部分的示例使用的是示例电影数据集。要了解如何将示例数据集加载到您的 MongoDB Atlas 部署中,请参阅加载示例数据。
要在 MongoDB Atlas 中投影查询返回的字段,请按照以下步骤操作:
在 MongoDB Atlas 用户界面中,转到您项目的 Clusters(集群)页面。
如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示,请从导航栏的 Projects 菜单中选择您的项目。
如果尚未出现,请单击侧边栏中的 Clusters(集群)。
会显示集群页面。
其他查询教程
有关其他查询示例,请参阅:
行为
Cursor
db.collection.find()
方法会返回指向匹配文档的游标。
MongoDB Compass Find 操作根据查找查询打开指向集合中匹配文档的游标。
有关如何在 MongoDB Compass 中进行采样的更多信息,请参阅 Compass 常见问题解答。
MongoCollection.Find() 方法会返回指向匹配文档的游标。有关迭代游标的信息,请参阅 MongoDB C# 驱动程序文档。
Collection.Find 函数会返回一个指向匹配文档的游标。有关更多信息,请参阅游标文档。
Collection.find() 方法会返回一个游标。
MongoDB::Collection::find() 方法会返回指向匹配文档的游标。有关迭代游标的信息,请参阅 MongoDB Perl 驱动程序文档。
MongoDB\\Collection::find()
方法会返回指向匹配文档的游标。有关迭代游标的信息,请参阅 MongoDB PHP 库文档。
pymongo.collection.Collection.find
方法会返回指向匹配文档的游标。有关如何迭代游标的信息,请参阅 PyMongo 文档。
Mongo::Collection#find() 方法会返回 CollectionView,它是 Enumerable
。游标是在枚举 View
时创建的;例如,通过调用 #to_a()
或 #each()
。您还可以通过在 Enumerator
上调用 #to_enum()
来获取 View
。有关迭代游标的信息,请参阅 Ruby 驱动程序 API 文档。
collection.find()方法会返回 findObservable 。
读取隔离性
关于对副本集和副本集分片的读取,读关注 (read concern) 允许客户端为其读取操作选择隔离级别。有关更多信息,请参阅读关注 (read concern) 。
查询结果格式
使用 MongoDB 驱动程序或 mongosh
运行查找操作时,命令会返回一个管理查询结果的游标。查询结果不会以大量文档的形式返回。
要了解如何迭代游标中的文档,请参阅驱动程序的文档。如果使用的是 mongosh
,请参阅在 mongosh
中迭代游标。
其他方法和选项
以下方法也可以从集合中读取文档:
注意
db.collection.findOne()
方法还执行读取操作以返回单个文档。在内部,db.collection.findOne()
方法是限值为 1 的 db.collection.find()
方法。
以下方法也可以从集合中读取文档:
注意
MongoCollection.FindOne() 方法还执行读取操作以返回单个文档。在内部,MongoCollection.FindOne() 方法是限值为 1 的 MongoCollection.Find() 方法。
以下方法也可以从集合中读取文档:
在聚合管道中,
$match
管道阶段提供对 MongoDB 查询的访问。请参阅 Collection.Aggregate。
以下方法也可以从集合中读取文档:
在聚合管道中,
$match
管道阶段提供对 MongoDB 查询的访问。有关更多信息,请参阅 com.mongodb.reactivestreams.client.MongoCollection.aggregate。
以下方法也可以从集合中读取文档:
在聚合管道中,
$match
管道阶段提供对 MongoDB 查询的访问。请参阅 Java 同步驱动程序聚合示例。
以下方法也可以从集合中读取文档:
注意
Collection.findOne() 方法还执行读取操作以返回单个文档。在内部,Collection.findOne()方法是 Collection.find() 方法,限制为 1。
以下方法也可以从集合中读取文档:
注意
MongoDB::Collection::find_one() 方法还执行读取操作以返回单个文档。在内部,MongoDB::Collection::find_one() 方法是限值为 1 的 MongoDB::Collection::find() 方法。
以下方法也可以从集合中读取文档:
注意
MongoDB\\Collection::findOne()
方法还执行读取操作以返回单个文档。在内部,MongoDB\\Collection::findOne()
方法是带有 1 限制的 MongoDB\\Collection::find()
方法。
以下方法也可以从集合中读取文档:
在聚合管道中,
$match
管道阶段提供对 MongoDB 查询的访问。请参阅 PyMongo 聚合示例。
注意
pymongo.collection.Collection.find_one
方法还执行读取操作以返回单个文档。在内部,pymongo.collection.Collection.find_one
方法是限值为 1 的 pymongo.collection.Collection.find
方法。