• MongoDB CRUD Operations >
• Query Documents >
• Query an Array

Query an Array

This page provides examples in:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

This page provides examples of query operations on array fields using the db.collection.find() method in the mongo shell. The examples on this page use the inventory collection. To populate the inventory collection, run the following:

This page provides examples of query operations on array fields using MongoDB Compass. The examples on this page use the inventory collection. Populate the inventory collection with the following documents:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

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. To populate the inventory collection, run the following:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

You can run the operation in the web shell below:

copy

[
  { 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.

copy

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

copy

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 ] }")
));

copy

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

copy

$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],
    ],
]);

copy

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

copy

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 ] }")
));

copy

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

copy

$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 ]
        }
    ]
);

copy

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

copy

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

copy

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.Background(), docs)

Match an Array

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala

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 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 eq( <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:

copy

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

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

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find( { tags => [ "red", "blank" ] } );

copy

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

copy

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

copy

cursor, err := coll.Find(
	context.Background(),
	bson.D{{"tags", bson.A{"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:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

Query an Array for an Element

• Mongo Shell
• Python
• Java (Sync)
• Node.js
• PHP
• Other
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala

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 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 eq( <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:

copy

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

<value> is the element value to match.

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:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

{ tags: "red" }

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find( { tags => "red" } );

copy

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

copy

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

copy

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

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala

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

copy

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

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

copy

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

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

copy

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

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

copy

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:

copy

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

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

copy

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

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

copy

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

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

copy

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:

copy

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:

copy

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

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

copy

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

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

copy

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.

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

{ dim_cm: { $gt: 25 } }

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find( { "dim_cm" => { '$gt' => 25 } } );

copy

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

copy

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

copy

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

Specify Multiple Conditions for Array Elements

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.

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

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find(
    { "dim_cm" => { '$gt' => 15, '$lt' => 20 } }
);

copy

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

copy

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

copy

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

Query for an Array Element that Meets Multiple Criteria

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:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find(
    { dim_cm => { '$elemMatch' => { '$gt' => 22, '$lt' => 30 } } }
);

copy

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

copy

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

copy

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

Query for an Element by the Array Index Position

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:

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find( { "dim_cm.1" => { '$gt' => 25 } } );

copy

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

copy

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

copy

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

Query an Array by Array Length

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.

• Mongo Shell
• Compass
• Python
• Java (Sync)
• Node.js
• Other
  • PHP
  • Motor
  • Java (Async)
  • C#
  • Perl
  • Ruby
  • Scala
  • Go

copy

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

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

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

copy

$cursor = $db->coll("inventory")->find( { tags => { '$size' => 3 } } );

copy

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

copy

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

copy

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

Additional Query Tutorials

For additional query examples, see:

• Query Documents
• Query on Embedded/Nested Documents
• Query an Array of Embedded Documents

←   Query on Embedded/Nested Documents Query an Array of Embedded Documents  →

© MongoDB, Inc 2008-present. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc.