Query Documents
On this page
To query documents, specify a query predicate indicating the
documents you want to return. If you specify an empty query predicate
({ }
), the query returns all documents in the collection.
You can query documents in MongoDB by using the following methods:
Your programming language's driver.
The MongoDB Atlas UI. To learn more, see Query Documents with MongoDB Atlas.
➤ Use the Select your language drop-down menu in the upper-right to set the language of the following examples or select MongoDB Compass.
This page provides examples of query operations using the
db.collection.find()
method in mongosh
.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using MongoDB Compass.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the MongoCollection.Find() method in the MongoDB C# Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the Collection.Find function in the MongoDB Go Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the com.mongodb.reactivestreams.client.MongoCollection.find method in the MongoDB Java Reactive Streams Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the com.mongodb.client.MongoCollection.find method in the MongoDB Java Synchronous Driver.
Tip
The driver provides com.mongodb.client.model.Filters helper methods to facilitate the creation of filter documents. The examples on this page use these methods to create the filter documents.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the
motor.motor_asyncio.AsyncIOMotorCollection.find
method in the Motor
driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the Collection.find() method in the MongoDB Node.js Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the MongoDB::Collection::find() method in the MongoDB Perl Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the
MongoDB\\Collection::find()
method in the
MongoDB PHP Library.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the
pymongo.collection.Collection.find
method in the
PyMongo
Python driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the Mongo::Collection#find() method in the MongoDB Ruby Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
This page provides examples of query operations using the collection.find() method in the MongoDB Scala Driver.
The examples on this page use the inventory
collection. Connect to a
test database in your MongoDB instance then create the inventory
collection:
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" } ]
For instructions on inserting documents in MongoDB Compass, see Insert Documents.
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()
Select All Documents in a Collection
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the query bar. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
To select all documents in the collection, pass an empty document as the query filter parameter to the find method. The query filter parameter determines the select criteria:
db.inventory.find( {} )
![Compass select all documents in collection](/docs/manual/static/10de84553f26db9bb923b4f40930d1f9/34491/compass-select-all.webp)
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())
This operation uses a query predicate of {}
, which corresponds to
the following SQL statement:
SELECT * FROM inventory
For more information on the syntax of the method, see
find()
.
For more information on the MongoDB Compass query bar, see Query Bar.
For more information on the syntax of the method, see Find().
For more information on the syntax of the method, see com.mongodb.reactivestreams.client.MongoCollection.find.
For more information on the syntax of the method, see com.mongodb.client.MongoCollection.find.
To see supported options for the find()
method, see
find().
For more information on the syntax of the method, see find().
For more information on the syntax of the method, see
find()
.
For more information on the syntax of the method, see
find
.
For more information on the syntax of the method, see find().
For more information on the syntax of the method, see collection.find().
Specify Equality Condition
To specify equality conditions, use <field>:<value>
expressions in the
query filter document:
{ <field1>: <value1>, ... }
To specify equality conditions, use <field>:<value>
expressions in the
query filter document:
{ <field1>: <value1>, ... }
To specify equality conditions, construct a filter using the Eq method:
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
To specify equality conditions, use the com.mongodb.client.model.Filters.eq method to create the query filter document:
and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)
To specify equality conditions, use the
com.mongodb.client.model.Filters.eq_
method to create the
query filter document:
and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)
To specify equality conditions, use <field>:<value>
expressions in the
query filter document:
{ <field1>: <value1>, ... }
To specify equality conditions, use <field>:<value>
expressions in the
query filter document:
{ <field1>: <value1>, ... }
To specify equality conditions, use <field> => <value>
expressions in the
query filter document:
{ <field1> => <value1>, ... }
To specify equality conditions, use <field> => <value>
expressions in the
query filter document:
[ <field1> => <value1>, ... ]
To specify equality conditions, use <field>:<value>
expressions in the
query filter document:
{ <field1>: <value1>, ... }
To specify equality conditions, use <field> => <value>
expressions in the
query filter document:
{ <field1> => <value1>, ... }
To specify equality conditions, use the
com.mongodb.client.model.Filters.eq_
method to create the
query filter document:
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
The following example selects from the inventory
collection all
documents where the status
equals "D"
:
db.inventory.find( { status: "D" } )
Copy the following filter into the Compass query bar and click 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"))
This operation uses a query predicate of { status: "D" }
, which
corresponds to the following SQL statement:
SELECT * FROM inventory WHERE status = "D"
Note
The MongoDB Compass query bar autocompletes the current query based on the keys in your collection's documents, including keys in embedded sub-documents.
Specify Conditions Using Query Operators
A query filter document can use the query operators to specify conditions in the following form:
{ <field1>: { <operator1>: <value1> }, ... }
A query filter document can use the query operators to specify conditions in the following form:
{ <field1>: { <operator1>: <value1> }, ... }
In addition to the equality filter, MongoDB provides various query operators to specify filter conditions. Use the FilterDefinitionBuilder methods to create a filter document. For example:
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
In addition to the equality condition, MongoDB provides various query operators to specify filter conditions. Use the com.mongodb.client.model.Filters helper methods to facilitate the creation of filter documents. For example:
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
In addition to the equality condition, MongoDB provides various query operators to specify filter conditions. Use the com.mongodb.client.model.Filters helper methods to facilitate the creation of filter documents. For example:
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
A query filter document can use the query operators to specify conditions in the following form:
{ <field1>: { <operator1>: <value1> }, ... }
A query filter document can use the query operators to specify conditions in the following form:
{ <field1>: { <operator1>: <value1> }, ... }
A query filter document can use the query operators to specify conditions in the following form:
{ <field1> => { <operator1> => <value1> }, ... }
A query filter document can use the query operators to specify conditions in the following form:
[ <field1> => [ <operator1> => <value1> ], ... ]
A query filter document can use the query operators to specify conditions in the following form:
{ <field1>: { <operator1>: <value1> }, ... }
A query filter document can use the query operators to specify conditions in the following form:
{ <field1> => { <operator1> => <value1> }, ... }
In addition to the equality condition, MongoDB provides
various query operators to specify
filter conditions. Use the
com.mongodb.client.model.Filters_
helper methods to
facilitate the creation of filter documents. For example:
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
The following example retrieves all documents from the inventory
collection where status
equals either "A"
or "D"
:
db.inventory.find( { status: { $in: [ "A", "D" ] } } )
Copy the following filter into the Compass query bar and click 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"))
Note
The operation uses a query predicate of
{ status: { $in: [ "A", "D" ] } }
, which corresponds to the
following SQL statement:
SELECT * FROM inventory WHERE status in ("A", "D")
Refer to the Query and Projection Operators document for the complete list of MongoDB query operators.
Specify AND
Conditions
A compound query can specify conditions for more than one field in the
collection's documents. Implicitly, a logical AND
conjunction
connects the clauses of a compound query so that the query selects the
documents in the collection that match all the conditions.
The following example retrieves all documents in the inventory
collection where the status
equals "A"
and qty
is less
than ($lt
) 30
:
db.inventory.find( { status: "A", qty: { $lt: 30 } } )
Copy the following filter into the Compass query bar and click 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)))
The operation uses a query predicate of
{ status: "A", qty: { $lt: 30 } }
, which corresponds to the
following SQL statement:
SELECT * FROM inventory WHERE status = "A" AND qty < 30
See comparison operators for other MongoDB comparison operators.
Specify OR
Conditions
Using the $or
operator, you can specify a compound query
that joins each clause with a logical OR
conjunction so that the
query selects the documents in the collection that match at least one
condition.
The following example retrieves all documents in the collection where
the status
equals "A"
or qty
is less than
($lt
) 30
:
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )
Copy the following filter into the Compass query bar and click 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)))
The operation uses a query predicate of
{ $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }
, which
corresponds to the following SQL statement:
SELECT * FROM inventory WHERE status = "A" OR qty < 30
Note
Queries that use comparison operators are subject to Type Bracketing.
Specify AND
as well as OR
Conditions
In the following example, the compound query document selects all
documents in the collection where the status
equals "A"
and either qty
is less than ($lt
) 30
or
item
starts with the character p
:
db.inventory.find( { status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] } )
Copy the following filter into the Compass query bar and click 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"))) )
The operation uses a query predicate of:
{ status: 'A', $or: [ { qty: { $lt: 30 } }, { item: { $regex: '^p' } } ] }
which corresponds to the following SQL statement:
SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")
Note
MongoDB supports regular expressions $regex
queries to
perform string pattern matches.
Query Documents with MongoDB Atlas
The example in this section uses the sample movies dataset. To learn how to load the sample dataset into your MongoDB Atlas deployment, see Load Sample Data.
To project fields to return from a query in MongoDB Atlas, follow these steps:
Specify the Filter field
Specify the query filter document in the Filter field. A query filter document uses query operators to specify search conditions.
Copy the following query filter document into the Filter search bar:
{ year: 1924 }
Additional Query Tutorials
For additional query examples, see:
Behavior
Cursor
The db.collection.find()
method
returns a cursor to the matching
documents.
The MongoDB Compass Find operation opens a cursor to the matching documents of the collection based on the find query.
For more information on sampling in MongoDB Compass, see the Compass FAQ.
The MongoCollection.Find() method returns a cursor to the matching documents. See the MongoDB C# driver documentation for iterating over a cursor.
The Collection.Find function returns a Cursor to the matching documents. See the Cursor documentation for more information.
com.mongodb.reactivestreams.client.MongoCollection.find returns an instance of the com.mongodb.reactivestreams.client.FindPublisher interface.
The com.mongodb.client.MongoCollection.find method returns an instance of the com.mongodb.client.FindIterable interface.
The Collection.find() method returns a cursor.
The MongoDB::Collection::find() method returns a cursor to the matching documents. See the MongoDB Perl driver documentation for iterating over a cursor.
The MongoDB\\Collection::find()
method returns a cursor to
the matching documents. See the MongoDB PHP Library
documentation for
iterating over a cursor.
The pymongo.collection.Collection.find
method
returns a cursor to the
matching documents. See the PyMongo documentation for
iterating over a cursor.
The Mongo::Collection#find()
method returns a CollectionView,
which is an Enumerable
. A Cursor is
created when the View
is enumerated; for example, by calling
#to_a()
or #each()
. You can also get an Enumerator
by calling
#to_enum()
on the View
. See the Ruby driver API documentation
for iterating over a cursor.
The collection.find() method returns the find Observable.
Read Isolation
For reads to Replica sets and replica set shards, read concern allows clients to choose a level of isolation for their reads. For more information, see Read Concern.
Query Result Format
When you run a find operation with a MongoDB driver or mongosh
, the
command returns a cursor that manages query results. The query
results are not returned as an array of documents.
To learn how to iterate through documents in a cursor, refer to your
driver's documentation. If you are using mongosh
, see
Iterate a Cursor in mongosh
.
Additional Methods and Options
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries.
Note
The db.collection.findOne()
method also performs a read
operation to return a single document. Internally, the
db.collection.findOne()
method is the
db.collection.find()
method with a limit of 1.
In addition to filter
, MongoDB Compass also allows the
following options to be passed to the query bar:
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB C# driver's LINQ documentation.
Note
The MongoCollection.FindOne() method also performs a read operation to return a single document. Internally, the MongoCollection.FindOne() method is the MongoCollection.Find() method with a limit of 1.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See Collection.Aggregate.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See com.mongodb.reactivestreams.client.MongoCollection.aggregate for more information.
The following methods can also read documents from a collection:
In the aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the Java Synchronous Driver Aggregation Examples.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB Node.js Driver's aggregation tutorial.
Note
The Collection.findOne() method also performs a read operation to return a single document. Internally, the Collection.findOne() method is the Collection.find() method with a limit of 1.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB Perl driver's aggregation examples.
Note
The MongoDB::Collection::find_one() method also performs a read operation to return a single document. Internally, the MongoDB::Collection::find_one() method is the MongoDB::Collection::find() method with a limit of 1.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB PHP Library's aggregation example.
Note
The MongoDB\\Collection::findOne()
method also performs a read operation to return a single
document. Internally, the
MongoDB\\Collection::findOne()
method is the
MongoDB\\Collection::find()
method with a limit of 1.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the PyMongo Aggregation Examples.
Note
The pymongo.collection.Collection.find_one
method also performs a read operation to return a single
document. Internally, the
pymongo.collection.Collection.find_one
method is
the pymongo.collection.Collection.find
method
with a limit of 1.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB Ruby driver's aggregation examples.
The following methods can also read documents from a collection:
In aggregation pipeline, the
$match
pipeline stage provides access to MongoDB queries. See the MongoDB Scala driver's aggregate method.