查询文档

在此页面上

选择集合中的所有文档

指定相等条件
使用查询操作符指定条件
指定 AND 条件
指定 OR 条件
指定 AND 和 OR 条件
使用 MongoDB Atlas 查询文档
其他查询教程
行为
其他方法和选项

您可以使用以下方法查询MongoDB中的文档：

您的编程语言的驱动程序。
MongoDB Atlas 用户界面。要了解更多信息，请参阅使用 MongoDB Atlas 查询文档。
MongoDB Compass。

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

本页面提供的示例展示使用 db.collection.find() 方法在 mongosh 中执行查询操作。

此页面上的示例使用的是 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 方法。查询筛选器参数决定选择条件：

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 查询栏根据集合文档中的键（包括嵌入式子文档中的键）自动完成当前查询。

使用查询操作符指定条件

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

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

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

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

以下示例从 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"))

注意

尽管您可以使用 $or 运算符来表示此查询，但在对同一字段进行相同检查时，请使用 $in 运算符而不是 $or 运算符。

该操作使用 { 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（集群）。
会显示集群页面。

导航至集合

对于包含样本数据的集群，单击Browse Collections 。
在左侧导航窗格中，选择 sample_mflix 数据库。
选择 movies 集合。

指定 Filter（筛选条件）字段

在 Filter 字段中指定查询筛选器文档。查询筛选器文档使用查询运算符来指定搜索条件。

将以下查询筛选器文档复制到 Filter 搜索栏：

{ year: 1924 }

单击 Apply

此查询筛选器返回 sample_mflix.movies 集合中 year 字段与 1924 匹配的所有文档。

其他查询教程

有关其他查询示例，请参阅：

行为

Cursor

db.collection.find() 方法会返回指向匹配文档的游标。

MongoDB Compass Find 操作根据查找查询打开指向集合中匹配文档的游标。

有关如何在 MongoDB Compass 中进行采样的更多信息，请参阅 Compass 常见问题解答。

MongoCollection.Find() 方法会返回指向匹配文档的游标。有关迭代游标的信息，请参阅 MongoDB C# 驱动程序文档。

Collection.Find 函数会返回一个指向匹配文档的游标。有关更多信息，请参阅游标文档。

com.mongodb.reactivestreams.client.MongoCollection.find 会返回 com.mongodb.reactivestreams.client.FindPublisher 接口实例。

com.mongodb.client.MongoCollection.find 方法会返回 com.mongodb.client.FindIterable 接口的一个实例。

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()
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。

注意

db.collection.findOne() 方法还执行读取操作以返回单个文档。在内部，db.collection.findOne() 方法是限值为 1 的 db.collection.find() 方法。

除了 filter 之外，MongoDB Compass 还允许将以下选项传递给查询栏：

项目	指定要在生成的数据中返回哪些字段。
Sort	指定返回文档的排序顺序。
跳过	指定返回结果集之前要跳过的前 n 个文档。
Limit	指定要返回的最大文档数。

以下方法也可以从集合中读取文档：

MongoCollection.FindOne()
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 MongoDB C# 驱动程序的 LINQ 文档。

注意

MongoCollection.FindOne() 方法还执行读取操作以返回单个文档。在内部，MongoCollection.FindOne() 方法是限值为 1 的 MongoCollection.Find() 方法。

以下方法也可以从集合中读取文档：

Collection.FindOne
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 Collection.Aggregate。

以下方法也可以从集合中读取文档：

在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。有关更多信息，请参阅 com.mongodb.reactivestreams.client.MongoCollection.aggregate。

以下方法也可以从集合中读取文档：

在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 Java 同步驱动程序聚合示例。

以下方法也可以从集合中读取文档：

Collection.findOne()
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 MongoDB Node.js 驱动程序的聚合教程。

注意

Collection.findOne() 方法还执行读取操作以返回单个文档。在内部，Collection.findOne()方法是 Collection.find() 方法，限制为 1。

以下方法也可以从集合中读取文档：

MongoDB::Collection::find_one()
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 MongoDB Perl 驱动程序的聚合示例。

注意

MongoDB::Collection::find_one() 方法还执行读取操作以返回单个文档。在内部，MongoDB::Collection::find_one() 方法是限值为 1 的 MongoDB::Collection::find() 方法。

以下方法也可以从集合中读取文档：

MongoDB\\Collection::findOne()
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 MongoDB PHP 库的聚合示例。

注意

MongoDB\\Collection::findOne() 方法还执行读取操作以返回单个文档。在内部，MongoDB\\Collection::findOne() 方法是带有 1 限制的 MongoDB\\Collection::find() 方法。

以下方法也可以从集合中读取文档：

pymongo.collection.Collection.find_one
在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 PyMongo 聚合示例。

注意

pymongo.collection.Collection.find_one 方法还执行读取操作以返回单个文档。在内部，pymongo.collection.Collection.find_one 方法是限值为 1 的 pymongo.collection.Collection.find 方法。

以下方法也可以从集合中读取文档：

在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参阅 MongoDB Ruby 驱动程序的聚合示例。

以下方法也可以从集合中读取文档：

在聚合管道中，$match 管道阶段提供对 MongoDB 查询的访问。请参见 MongoDB Scala 驱动程序的聚合方法。

后退

方法

来年

嵌入式文档

提示

选择集合中的所有文档

指定相等条件

注意

使用查询操作符指定条件

注意

指定 AND 条件

指定 OR 条件

注意

指定 AND 和 OR 条件

注意

使用 MongoDB Atlas 查询文档

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

导航至集合

指定 Filter（筛选条件）字段

单击 Apply

其他查询教程

行为

Cursor

读取隔离性

查询结果格式

其他方法和选项

注意

注意

注意

注意

注意

注意

指定 `AND` 条件

指定 `OR` 条件

指定 `AND` 和 `OR` 条件