Query an Array

Match an Array

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.

The following example queries for all documents where genres is an array with exactly two elements, "Action" and "Comedy", in the specified order:

db.movies.find( { genres: ["Action", "Comedy"] } )

To find an array that contains both "Action" and "Comedy" regardless of order or other elements in the array, use the $all operator:

db.movies.find( { genres: { $all: ["Action", "Comedy"] } } )

Query an Array for an Element

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 array contains the string "Short" as one of its elements:

db.movies.find( { genres: "Short" } )

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

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

The following example queries for all documents where the cast array contains at least one element that matches the regular expression ^A:

db.movies.find( { cast: { $regex: "^A" } } )

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

db.movies.find(
   { cast: { $regex: "^A", $ne: "Adam Sandler" } }
)

db.movies.find(
   { cast: { $elemMatch: { $regex: "^A", $ne: "Adam Sandler" } } }
)

db.movies.find( { "cast.0": "Tom Hanks" } )

db.movies.find( { genres: { $size: 3 } } )

Match an Array

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.

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

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

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

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

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

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

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

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

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

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

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

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

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

Match an Array

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.

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

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

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

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

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

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

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

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

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

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

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

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

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

Match an Array

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.

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

FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

findIterable = collection.find(all("tags", asList("red", "blank")));

Query an Array for an Element

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.

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

findIterable = collection.find(eq("tags", "red"));

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

findIterable = collection.find(gt("dim_cm", 25));

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));

findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

findIterable = collection.find(gt("dim_cm.1", 25));

findIterable = collection.find(size("tags", 3));

Match an Array

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.

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

FindPublisher<Document> findPublisher = collection.find(eq("tags", asList("red", "blank")));

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

findPublisher = collection.find(all("tags", asList("red", "blank")));

Query an Array for an Element

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.

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

findPublisher = collection.find(eq("tags", "red"));

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

findPublisher = collection.find(gt("dim_cm", 25));

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

findPublisher = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));

findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

findPublisher = collection.find(size("tags", 3));

Match an Array

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.

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

val findFlow = collection
    .find(eq("tags", listOf("red", "blank")))

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

val findFlow = collection
    .find(all("tags", listOf("red", "blank")))

Query an Array for an Element

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.

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

val findFlow = collection
    .find(eq("tags", "red"))

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

val findFlow = collection
    .find(gt("dim_cm", 25))

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

val findFlow = collection
    .find(and(gt("dim_cm", 15), lt("dim_cm", 20)))

val findFlow = collection
    .find(elemMatch("dim_cm", Document.parse("{ \$gt: 22, \$lt: 30 }")))

val findFlow = collection
    .find(gt("dim_cm.1", 25))

val findFlow = collection
    .find(size("tags", 3))

Match an Array

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.

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

const cursor = db.collection('inventory').find({
  tags: ['red', 'blank']
});

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

const cursor = db.collection('inventory').find({
  tags: { $all: ['red', 'blank'] }
});

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

const cursor = db.collection('inventory').find({
  tags: 'red'
});

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

const cursor = db.collection('inventory').find({
  dim_cm: { $gt: 25 }
});

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

const cursor = db.collection('inventory').find({
  dim_cm: { $gt: 15, $lt: 20 }
});

const cursor = db.collection('inventory').find({
  dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } }
});

const cursor = db.collection('inventory').find({
  'dim_cm.1': { $gt: 25 }
});

const cursor = db.collection('inventory').find({
  tags: { $size: 3 }
});

Match an Array

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.

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

$cursor = $db->inventory->find(['tags' => ['red', 'blank']]);

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

$cursor = $db->inventory->find(['tags' => ['$all' => ['red', 'blank']]]);

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

$cursor = $db->inventory->find(['tags' => 'red']);

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

$cursor = $db->inventory->find(['dim_cm' => ['$gt' => 25]]);

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

$cursor = $db->inventory->find([
    'dim_cm' => [
        '$gt' => 15,
        '$lt' => 20,
    ],
]);

$cursor = $db->inventory->find([
    'dim_cm' => [
        '$elemMatch' => [
            '$gt' => 22,
            '$lt' => 30,
        ],
    ],
]);

$cursor = $db->inventory->find(['dim_cm.1' => ['$gt' => 25]]);

$cursor = $db->inventory->find(['tags' => ['$size' => 3]]);

Match an Array

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.

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

client[:inventory].find(tags: %w[red blank])

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

client[:inventory].find(tags: { '$all' => %w[red blank] })

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

client[:inventory].find(tags: 'red')

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

client[:inventory].find(dim_cm: { '$gt' => 25 })

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

client[:inventory].find(dim_cm: { '$gt' => 15,
                                  '$lt' => 20 })

client[:inventory].find(dim_cm: { '$elemMatch' => { '$gt' => 22,
                                                    '$lt' => 30 } })

client[:inventory].find('dim_cm.1' => { '$gt' => 25 })

client[:inventory].find(tags: { '$size' => 3 })

Match an Array

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 tags is an array with exactly two elements, "red" and "blank", in the specified order:

var findObservable = collection.find(equal("tags", Seq("red", "blank")))

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

findObservable = collection.find(all("tags", "red", "blank"))

Query an Array for an Element

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 the tags array contains the string "red" as one of its elements:

findObservable = collection.find(equal("tags", "red"))

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

findObservable = collection.find(gt("dim_cm", 25))

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

findObservable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))

findObservable = collection.find(elemMatch("dim_cm", Document("$gt" -> 22, "$lt" -> 30)))

findObservable = collection.find(gt("dim_cm.1", 25))

findObservable = collection.find(size("tags", 3))

Match an Array

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

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

var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" });
var result = collection.Find(filter).ToList();

Query an Array for an Element

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

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

var filter = Builders<BsonDocument>.Filter.Eq("tags", "red");
var result = collection.Find(filter).ToList();

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25);
var result = collection.Find(filter).ToList();

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

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();

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } });
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25);
var result = collection.Find(filter).ToList();

var filter = Builders<BsonDocument>.Filter.Size("tags", 3);
var result = collection.Find(filter).ToList();

Match an Array

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.

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

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

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

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

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

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

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

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

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

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

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

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

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

Match an Array

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.

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

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"tags", bson.A{"red", "blank"}}},
)

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", bson.D{{"$all", bson.A{"red", "blank"}}}},
	})

Query an Array for an Element

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.

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

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", "red"},
	})

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

filter := bson.D{
    {"$and", bson.A{
        bson.D{{<array field>, bson.D{{"$eq", <value1>}}}},
        bson.D{{<array field>, bson.D{{"$lt", <value2>}}}},
    }},
}

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$gt", 25},
		}},
	})

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$gt", 15},
			{"$lt", 20},
		}},
	})

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm", bson.D{
			{"$elemMatch", bson.D{
				{"$gt", 22},
				{"$lt", 30},
			}},
		}},
	})

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"dim_cm.1", bson.D{
			{"$gt", 25},
		}},
	})

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"tags", bson.D{
			{"$size", 3},
		}},
	})

Match an Array

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.

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

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

{ tags: ["red", "blank"] }

To find an array that contains both "red" and "blank" regardless of order or other elements in the array, use the $all operator:

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

{ tags: { $all: ["red", "blank"] } }

Query an Array for an Element

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 tags array contains the string "red" as one of its elements:

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

{ tags: "red" }

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

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

The following example queries for all documents where the array dim_cm contains at least one element whose value is greater than 25:

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

{ dim_cm: { $gt: 25 } }

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

Query an Array with Compound Filter Conditions on the Array Elements

The following example queries for documents where the dim_cm array contains elements that in some combination satisfy the query conditions. 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:

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

{ dim_cm: { $gt: 15, $lt: 20 } }

Query for an Array Element that Meets Multiple Criteria

Use the $elemMatch operator to specify multiple criteria on array elements so 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:

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

{ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } }

Query for an Element by the Array Index Position

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

Note

When you query 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:

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

{ "dim_cm.1": { $gt: 25 } }

{ "tags": { $size: 3 } }

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

Match an Array

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 where genres contains the ["Action", "Comedy"] array in the specified order:

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

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

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

Query an Array for an Element

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>, ... } }

The following example uses the $nin operator to query for all documents where the genres field does not contain Drama:

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

Specify Multiple Conditions for Array Elements

When you specify compound conditions on array elements, you can query for documents where either:

• A single array element meets all the specified conditions

• Different array elements collectively meet all the conditions, with each element satisfying one or more conditions

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

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

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

{ genres: { $size: 3 } }