Docs Menu
Docs Home
/
MongoDB Manual
/ /

Query an Array

On this page

  • Match an Array
  • Query an Array for an Element
  • Specify Multiple Conditions for Array Elements
  • Query an Array with MongoDB Atlas
  • Additional Query Tutorials

You can query arrays in MongoDB using the following methods:

  • Your programming language's driver.

  • The MongoDB Atlas UI. To learn more, see Query an Array with MongoDB Atlas.

  • MongoDB Compass.


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 on array fields 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 on array fields 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 on array fields using mongoc_collection_find_with_opts.

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 on array fields 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 on array fields 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 on array fields 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 on array fields 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 on array fields by using the MongoCollection.find() method in the MongoDB Kotlin Coroutine 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 on array fields 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 on array fields 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 on array fields 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 on array fields 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 on array fields 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 on array fields 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 on array fields 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, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);
[
{ "item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [ 14, 21 ] },
{ "item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [ 14, 21 ] },
{ "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [ 14, 21 ] },
{ "item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [ 22.85, 30 ] },
{ "item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [ 10, 15.25 ] }
]

For instructions on inserting documents in MongoDB Compass, see Insert Documents.

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),
"tags", "[",
BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
"]",
"dim_cm", "[",
BCON_INT64 (14), BCON_INT64 (21),
"]");
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),
"tags", "[",
BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
"]",
"dim_cm", "[",
BCON_INT64 (14), BCON_INT64 (21),
"]");
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),
"tags", "[",
BCON_UTF8 ("red"), BCON_UTF8 ("blank"), BCON_UTF8 ("plain"),
"]",
"dim_cm", "[",
BCON_INT64 (14), BCON_INT64 (21),
"]");
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),
"tags", "[",
BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
"]",
"dim_cm", "[",
BCON_DOUBLE (22.85), BCON_INT64 (30),
"]");
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),
"tags", "[",
BCON_UTF8 ("blue"),
"]",
"dim_cm", "[",
BCON_INT64 (10), BCON_DOUBLE (15.25),
"]");
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 },
{ "tags", new BsonArray { "blank", "red" } },
{ "dim_cm", new BsonArray { 14, 21 } }
},
new BsonDocument
{
{ "item", "notebook" },
{ "qty", 50 },
{ "tags", new BsonArray { "red", "blank" } },
{ "dim_cm", new BsonArray { 14, 21 } }
},
new BsonDocument
{
{ "item", "paper" },
{ "qty", 100 },
{ "tags", new BsonArray { "red", "blank", "plain" } },
{ "dim_cm", new BsonArray { 14, 21 } }
},
new BsonDocument
{
{ "item", "planner" },
{ "qty", 75 },
{ "tags", new BsonArray { "blank", "red" } },
{ "dim_cm", new BsonArray { 22.85, 30 } }
},
new BsonDocument
{
{ "item", "postcard" },
{ "qty", 45 },
{ "tags", new BsonArray { "blue" } },
{ "dim_cm", new BsonArray { 10, 15.25 } }
}
};
collection.InsertMany(documents);
docs := []interface{}{
bson.D{
{"item", "journal"},
{"qty", 25},
{"tags", bson.A{"blank", "red"}},
{"dim_cm", bson.A{14, 21}},
},
bson.D{
{"item", "notebook"},
{"qty", 50},
{"tags", bson.A{"red", "blank"}},
{"dim_cm", bson.A{14, 21}},
},
bson.D{
{"item", "paper"},
{"qty", 100},
{"tags", bson.A{"red", "blank", "plain"}},
{"dim_cm", bson.A{14, 21}},
},
bson.D{
{"item", "planner"},
{"qty", 75},
{"tags", bson.A{"blank", "red"}},
{"dim_cm", bson.A{22.85, 30}},
},
bson.D{
{"item", "postcard"},
{"qty", 45},
{"tags", bson.A{"blue"}},
{"dim_cm", bson.A{10, 15.25}},
},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));
collection.insertMany(asList(
Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));
collection.insertMany(
listOf(
Document("item", "journal")
.append("qty", 25)
.append("tags", listOf("blank", "red"))
.append("dim_cm", listOf(14, 21)),
Document("item", "notebook")
.append("qty", 50)
.append("tags", listOf("red", "blank"))
.append("dim_cm", listOf(14, 21)),
Document("item", "paper")
.append("qty", 100)
.append("tags", listOf("red", "blank", "plain"))
.append("dim_cm", listOf(14, 21)),
Document("item", "planner")
.append("qty", 75)
.append("tags", listOf("blank", "red"))
.append("dim_cm", listOf(22.85, 30)),
Document("item", "postcard")
.append("qty", 45)
.append("tags", listOf("blue"))
.append("dim_cm", listOf(10, 15.25)),
)
)
await db.inventory.insert_many(
[
{"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
{"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
{
"item": "paper",
"qty": 100,
"tags": ["red", "blank", "plain"],
"dim_cm": [14, 21],
},
{"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
{"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
]
)
await db.collection('inventory').insertMany([
{
item: 'journal',
qty: 25,
tags: ['blank', 'red'],
dim_cm: [14, 21]
},
{
item: 'notebook',
qty: 50,
tags: ['red', 'blank'],
dim_cm: [14, 21]
},
{
item: 'paper',
qty: 100,
tags: ['red', 'blank', 'plain'],
dim_cm: [14, 21]
},
{
item: 'planner',
qty: 75,
tags: ['blank', 'red'],
dim_cm: [22.85, 30]
},
{
item: 'postcard',
qty: 45,
tags: ['blue'],
dim_cm: [10, 15.25]
}
]);
$db->coll("inventory")->insert_many(
[
{
item => "journal",
qty => 25,
tags => [ "blank", "red" ],
dim_cm => [ 14, 21 ]
},
{
item => "notebook",
qty => 50,
tags => [ "red", "blank" ],
dim_cm => [ 14, 21 ]
},
{
item => "paper",
qty => 100,
tags => [ "red", "blank", "plain" ],
dim_cm => [ 14, 21 ]
},
{
item => "planner",
qty => 75,
tags => [ "blank", "red" ],
dim_cm => [ 22.85, 30 ]
},
{
item => "postcard",
qty => 45,
tags => ["blue"],
dim_cm => [ 10, 15.25 ]
}
]
);
$insertManyResult = $db->inventory->insertMany([
[
'item' => 'journal',
'qty' => 25,
'tags' => ['blank', 'red'],
'dim_cm' => [14, 21],
],
[
'item' => 'notebook',
'qty' => 50,
'tags' => ['red', 'blank'],
'dim_cm' => [14, 21],
],
[
'item' => 'paper',
'qty' => 100,
'tags' => ['red', 'blank', 'plain'],
'dim_cm' => [14, 21],
],
[
'item' => 'planner',
'qty' => 75,
'tags' => ['blank', 'red'],
'dim_cm' => [22.85, 30],
],
[
'item' => 'postcard',
'qty' => 45,
'tags' => ['blue'],
'dim_cm' => [10, 15.25],
],
]);
db.inventory.insert_many(
[
{"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
{"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
{
"item": "paper",
"qty": 100,
"tags": ["red", "blank", "plain"],
"dim_cm": [14, 21],
},
{"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
{"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
]
)
client[:inventory].insert_many([{ item: 'journal',
qty: 25,
tags: ['blank', 'red'],
dim_cm: [ 14, 21 ] },
{ item: 'notebook',
qty: 50,
tags: ['red', 'blank'],
dim_cm: [ 14, 21 ] },
{ item: 'paper',
qty: 100,
tags: ['red', 'blank', 'plain'],
dim_cm: [ 14, 21 ] },
{ item: 'planner',
qty: 75,
tags: ['blank', 'red'],
dim_cm: [ 22.85, 30 ] },
{ item: 'postcard',
qty: 45,
tags: ['blue'],
dim_cm: [ 10, 15.25 ] }
])
collection.insertMany(Seq(
Document("""{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }"""),
Document("""{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }"""),
Document("""{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }"""),
Document("""{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }"""),
Document("""{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }""")
)).execute()

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, construct a filter using the Eq method, where <value> is the exact array to match, including the order of the elements:

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

To specify equality condition on an array, use the query document eq( <field>, <value>) where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document eq( <field>, <value>) where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field> => <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document [ <field> => <value> ] where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document { <field> => <value> } where <value> is the exact array to match, including the order of the elements.

To specify equality condition on an array, use the query document equal( <field>, <value> ) where <value> is the exact array to match, including the order of the elements.

The following example queries for all documents where the field tags value is an array with exactly two elements, "red" and "blank", in the specified order:

db.inventory.find( { tags: ["red", "blank"] } )

Copy the following filter into the Compass query bar and click Find:

{ tags: ["red", "blank"] }
Query array matching exactly
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"tags", "[",
BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
"]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{{"tags", bson.A{"red", "blank"}}},
)
FindPublisher<Document> findPublisher = collection.find(eq("tags", asList("red", "blank")));
FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));
val findFlow = collection
.find(eq("tags", listOf("red", "blank")))
cursor = db.inventory.find({"tags": ["red", "blank"]})
const cursor = db.collection('inventory').find({
tags: ['red', 'blank']
});
$cursor = $db->coll("inventory")->find( { tags => [ "red", "blank" ] } );
$cursor = $db->inventory->find(['tags' => ['red', 'blank']]);
cursor = db.inventory.find({"tags": ["red", "blank"]})
client[:inventory].find(tags: ['red', 'blank'])
var findObservable = collection.find(equal("tags", Seq("red", "blank")))

If, instead, you wish to find an array that contains both the elements "red" and "blank", without regard to order or other elements in the array, use the $all operator:

db.inventory.find( { tags: { $all: ["red", "blank"] } } )

Copy the following filter into the Compass query bar and click Find:

{ tags: { $all: ["red", "blank"] } }
Query array matching all criteria
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"tags", "{",
"$all", "[",
BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
"]",
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"tags", bson.D{{"$all", bson.A{"red", "blank"}}}},
})
findPublisher = collection.find(all("tags", asList("red", "blank")));
findIterable = collection.find(all("tags", asList("red", "blank")));
val findFlow = collection
.find(all("tags", listOf("red", "blank")))
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
const cursor = db.collection('inventory').find({
tags: { $all: ['red', 'blank'] }
});
$cursor = $db->coll("inventory")->find( { tags => { '$all' => [ "red", "blank" ] } } );
$cursor = $db->inventory->find(['tags' => ['$all' => ['red', 'blank']]]);
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
client[:inventory].find(tags: { '$all' => ['red', 'blank'] })
findObservable = collection.find(all("tags", "red", "blank"))

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, construct a filter using the Eq method, where <value> is the element value to match:

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

To query if the array field contains at least one element with the specified value, use the filter eq( <field>, <value>) where value is the element value.

To query if the array field contains at least one element with the specified value, use the filter eq( <field>, <value>) where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter

{ <field> => <value> } where value is the element value.

To query if the array field contains at least one element with the specified value, use the filter [ <field> => <value> ] where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter { <field> => <value> } where <value> is the element value.

To query if the array field contains at least one element with the specified value, use the filter equal( <field>, <value> ) where <value> is the element value.

The following example queries for all documents where tags is an array that contains the string "red" as one of its elements:

db.inventory.find( { tags: "red" } )

Copy the following filter into the Compass query bar and click Find:

{ tags: "red" }
Query array matching multiple criteria
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("tags", BCON_UTF8 ("red"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("tags", "red");
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"tags", "red"},
})
findPublisher = collection.find(eq("tags", "red"));
findIterable = collection.find(eq("tags", "red"));
val findFlow = collection
.find(eq("tags", "red"))
cursor = db.inventory.find({"tags": "red"})
const cursor = db.collection('inventory').find({
tags: 'red'
});
$cursor = $db->coll("inventory")->find( { tags => "red" } );
$cursor = $db->inventory->find(['tags' => 'red']);
cursor = db.inventory.find({"tags": "red"})
client[:inventory].find(tags: 'red')
findObservable = collection.find(equal("tags", "red"))

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document. For example:

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<array field>, <value1>), builder.Lt(<array field>, <value2>));

To specify conditions on the elements in the array field, use query operators in the query filter document. For example:

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

To specify conditions on the elements in the array field, use query operators in the query filter document. For example:

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

To specify conditions on the elements in the array field, use query operators in the query filter document. For example:

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field> => { <operator1> => <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

[ <array field> => [ <operator1> => <value1>, ... ] ]

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field> => { <operator1> => <value1>, ... } }

To specify conditions on the elements in the array field, use query operators in the query filter document:

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

For example, the following operation queries for all documents where the array dim_cm contains at least one element whose value is greater than 25.

db.inventory.find( { dim_cm: { $gt: 25 } } )

Copy the following filter into the Compass query bar and click Find:

{ dim_cm: { $gt: 25 } }
Query array for at least one matching element
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"dim_cm", "{",
"$gt", BCON_INT64 (25),
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25);
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"dim_cm", bson.D{
{"$gt", 25},
}},
})
findPublisher = collection.find(gt("dim_cm", 25));
findIterable = collection.find(gt("dim_cm", 25));
val findFlow = collection
.find(gt("dim_cm", 25))
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
const cursor = db.collection('inventory').find({
dim_cm: { $gt: 25 }
});
$cursor = $db->coll("inventory")->find( { "dim_cm" => { '$gt' => 25 } } );
$cursor = $db->inventory->find(['dim_cm' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
client[:inventory].find(dim_cm: { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm", 25))

When specifying compound conditions on array elements, you can specify the query such that either a single array element meets these condition or any combination of array elements meets the conditions.

The following example queries for documents where the dim_cm array contains elements that in some combination satisfy the query conditions; e.g., one element can satisfy the greater than 15 condition and another element can satisfy the less than 20 condition, or a single element can satisfy both:

db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )

Copy the following filter into the Compass query bar and click Find:

{ dim_cm: { $gt: 15, $lt: 20 } }
Query array using a compound filter
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"dim_cm", "{",
"$gt", BCON_INT64 (15),
"$lt", BCON_INT64 (20),
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"dim_cm", bson.D{
{"$gt", 15},
{"$lt", 20},
}},
})
findPublisher = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
val findFlow = collection
.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
const cursor = db.collection('inventory').find({
dim_cm: { $gt: 15, $lt: 20 }
});
$cursor = $db->coll("inventory")->find(
{ "dim_cm" => { '$gt' => 15, '$lt' => 20 } }
);
$cursor = $db->inventory->find([
'dim_cm' => [
'$gt' => 15,
'$lt' => 20,
],
]);
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
client[:inventory].find(dim_cm: { '$gt' => 15,
'$lt' => 20 })
findObservable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))

Use $elemMatch operator to specify multiple criteria on the elements of an array such that at least one array element satisfies all the specified criteria.

The following example queries for documents where the dim_cm array contains at least one element that is both greater than ($gt) 22 and less than ($lt) 30:

db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )

Copy the following filter into the Compass query bar and click Find:

{ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } }
Query array by multiple conditions
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"dim_cm", "{",
"$elemMatch", "{",
"$gt", BCON_INT64 (22),
"$lt", BCON_INT64 (30),
"}",
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"dim_cm", bson.D{
{"$elemMatch", bson.D{
{"$gt", 22},
{"$lt", 30},
}},
}},
})
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
val findFlow = collection
.find(elemMatch("dim_cm", Document.parse("{ \$gt: 22, \$lt: 30 }")))
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
const cursor = db.collection('inventory').find({
dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } }
});
$cursor = $db->coll("inventory")->find(
{ dim_cm => { '$elemMatch' => { '$gt' => 22, '$lt' => 30 } } }
);
$cursor = $db->inventory->find([
'dim_cm' => [
'$elemMatch' => [
'$gt' => 22,
'$lt' => 30,
],
],
]);
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
client[:inventory].find(dim_cm: { '$elemMatch' => { '$gt' => 22,
'$lt' => 30 } })
findObservable = collection.find(elemMatch("dim_cm", Document("$gt" -> 22, "$lt" -> 30)))

Using dot notation, you can specify query conditions for an element at a particular index or position of the array. The array uses zero-based indexing.

Note

When querying using dot notation, the field and nested field must be inside quotation marks.

The following example queries for all documents where the second element in the array dim_cm is greater than 25:

db.inventory.find( { "dim_cm.1": { $gt: 25 } } )

Copy the following filter into the Compass query bar and click Find:

{ "dim_cm.1": { $gt: 25 } }
Query array by index
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"dim_cm.1", "{",
"$gt", BCON_INT64 (25),
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25);
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"dim_cm.1", bson.D{
{"$gt", 25},
}},
})
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(gt("dim_cm.1", 25));
val findFlow = collection
.find(gt("dim_cm.1", 25))
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
const cursor = db.collection('inventory').find({
'dim_cm.1': { $gt: 25 }
});
$cursor = $db->coll("inventory")->find( { "dim_cm.1" => { '$gt' => 25 } } );
$cursor = $db->inventory->find(['dim_cm.1' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
client[:inventory].find('dim_cm.1' => { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm.1", 25))

Use the $size operator to query for arrays by number of elements. For example, the following selects documents where the array tags has 3 elements.

db.inventory.find( { "tags": { $size: 3 } } )

Copy the following filter into the Compass query bar and click Find:

{ "tags": { $size: 3 } }
Query for array by number of elements
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
"tags", "{",
"$size", BCON_INT64 (3),
"}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

Be sure to also clean up any open resources by calling the following methods, as appropriate:

var filter = Builders<BsonDocument>.Filter.Size("tags", 3);
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
context.TODO(),
bson.D{
{"tags", bson.D{
{"$size", 3},
}},
})
findPublisher = collection.find(size("tags", 3));
findIterable = collection.find(size("tags", 3));
val findFlow = collection
.find(size("tags", 3))
cursor = db.inventory.find({"tags": {"$size": 3}})
const cursor = db.collection('inventory').find({
tags: { $size: 3 }
});
$cursor = $db->coll("inventory")->find( { tags => { '$size' => 3 } } );
$cursor = $db->inventory->find(['tags' => ['$size' => 3]]);
cursor = db.inventory.find({"tags": {"$size": 3}})
client[:inventory].find(tags: { '$size' => 3 })
findObservable = collection.find(size("tags", 3))

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 query an array in MongoDB Atlas, follow these steps:

1
  1. In the MongoDB Atlas UI, click Database in the sidebar.

  2. For the database deployment that contains the sample data, click Browse Collections.

  3. In the left navigation pane, select the sample_mflix database.

  4. Select the movies collection.

2

To query a document that contains an array, specify a query filter document. A query filter document uses query operators to specify search conditions. Use the following example documents to query array fields in the sample_mflix.movies collection.

To apply a query filter, copy an example document into the Filter search bar and click Apply.

To specify an equality condition on an array, use the query document { <field>: <value> } where <value> is the exact array to match, including the order of the elements. The following example finds documents that have a genres field that contains the ["Action", "Comedy"] array in the specified order:

{ genres: ["Action", "Comedy"] }

To find an array that contains both the elements Action and Comedy, without regard to order or other elements in the array, use the $all operator:

{ genres: { $all: ["Action", "Comedy"] } }

To query if the array field contains at least one element with the specified value, use the filter { <field>: <value> } where <value> is the element value.

The following example queries for all documents where the genres field contains the string Short as one of its elements:

{ genres: "Short" }

To specify conditions on the elements in the array field, use query operators in the query filter document:

{ <array field>: { <operator1>: <value1>, ... } }

For example, the following operation uses the $nin operator to query for all documents where the genres field does not contain Drama.

{ genres: { $nin: ["Drama"] } }

When specifying compound conditions on array elements, you can specify the query such that either a single array element meets these condition or any combination of array elements meets the conditions.

The following example queries for documents where the cast array contains elements that in some combination satisfy the query conditions. For example, the following filter uses the $regex and $eq operators to return documents where a single array element ends in Olsen and another element equals Mary-Kate Olsen or a single element that satisfies both conditions:

{ cast: { $regex: "Olsen$", $eq: "Mary-Kate Olsen" } }

This query filter returns movies that include Mary-Kate Olsen in their cast, and movies that include both Mary-Kate Olsen and Ashley Olsen in their cast.

Use $elemMatch operator to specify multiple criteria on the elements of an array such that at least one array element satisfies all the specified criteria.

The following example uses the $elemMatch and $ne operators to query for documents where the languages array contains at least one element that is both not null and does not equal English.

{ languages: { $elemMatch: { $ne: null, $ne: "English" } } }

Using dot notation, you can specify query conditions for an element at a particular index or position of the array. The array uses zero-based indexing.

Note

When querying using dot notation, the field and nested field must be inside quotation marks.

The following example uses the $ne operator to query for all documents where the first element in the countries array is not equal to USA:

{ "countries.0": { $ne: "USA" }

Use the $size operator to query for arrays by number of elements. For example, the following selects documents where the array genres has 3 elements.

{ genres: { $size: 3 } }

For additional query examples, see:

Back

Query on Embedded/Nested Documents

Next

Query an Array of Embedded Documents