Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Consultas em uma array

Nesta página

Combine uma array

Fazer uma query de uma array para um elemento
Especificar várias condições para elementos de Array
Fazer uma query de uma array com MongoDB Atlas
Tutoriais de consultas adicionais

Você pode fazer queries de arrays no MongoDB usando os seguintes métodos:

O driver da sua linguagem de programação.
A UI do MongoDB Atlas. Para saber mais, consulte Fazer query de uma array com o MongoDB Atlas.
MongoDB Compass.

➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir ou selecione MongoDB Compass.

Esta página fornece exemplos de operações de query em campos de array usando o método db.collection.find() em mongosh.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array utilizando o MongoDB Compass.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o MongoCollection.Find() no MongoDB C# Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de query de consulta em campos de array usando o Collection.Find função no MongoDB Go Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o com.mongodb.reactivestreams.client.MongoCollection.find no Driver Java Reactive Streams do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de consulta em campos de array utilizando o método com.mongodb.client.MongoCollection.find no Java Synchronous Driver do MongoDB.

Dica

O driver fornece com.mongodb.client.model.Filters métodos auxiliares para facilitar a criação de documentos de filtro. Os exemplos nesta página usam esses métodos para criar os documentos de filtro.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o motor.motor_asyncio.AsyncIOMotorCollection.find no Motor motorista.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de query de consulta em campos de array usando o Collection.find() no MongoDB Node.js Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o MongoDB::Collection::find() no MongoDB Perl Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o método MongoDB\\Collection::find() na Biblioteca PHP do MongoDB.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de consulta em campos de array usando o método pymongo.collection.Collection.find no driver PyMongo Python.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de operações de query em campos de array usando o método Mongo::Collection#find() no MongoDB Ruby Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página fornece exemplos de query de consulta em campos de array usando o método collection.find() no MongoDB Scala Driver.

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

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

Para obter instruções sobre como inserir documentos no MongoDB Compass, consulte Insira documentos.

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

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

Combine uma array

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar a condição de igualdade em uma array, construa um filtro usando o método Eq:

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

<value> é a array exata a ser correspondida, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query eq( <field>, <value>) onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query eq( <field>, <value>) onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field> => <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query [ <field> => <value> ] onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field> => <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

Para especificar uma condição de igualdade em uma array, utilize o documento de query equal( <field>, <value> ) onde <value> é a array exata para corresponder, incluindo a ordem dos elementos.

As seguintes queries de exemplo para todos os documentos onde o valor do campo tags é uma array com exatamente dois elementos, "red" e "blank", na ordem especificada:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

Array de query que corresponde exatamente

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

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

Se, em vez disso, você quiser encontrar uma array que contenha os elementos "red" e "blank", sem levar em conta a ordem ou outros elementos da array, use o operador $all:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

Array de query que corresponda a todos os critérios

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

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

Fazer uma query de uma array para um elemento

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field>: <value> } onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, construa um filtro usando o Eq método:

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

<value> é o valor do elemento a ser correspondido.

Para query se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro eq( <field>, <value>) onde o valor é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro eq( <field>, <value>) onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field>: <value> } onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field>: <value> } onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, use o filtro

{ <field> => <value> } onde valor é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro [ <field> => <value> ] onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field>: <value> } onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field> => <value> } onde <value> é o valor do elemento.

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro equal( <field>, <value> ) onde <value> é o valor do elemento.

As seguintes queries de exemplo para todos os documentos onde tags é uma array que contém a string "red" como um de seus elementos:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

{ tags: "red" }

Array de query que corresponde a vários critérios

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

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query. Por exemplo:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query. Por exemplo:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query. Por exemplo:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Por exemplo, a operação a seguir consulta todos os documentos onde o array dim_cm contém pelo menos um elemento cujo valor seja maior que 25.

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

{ dim_cm: { $gt: 25 } }

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

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

Especificar várias condições para elementos de Array

Ao especificar condições compostas em elementos de array, você pode especificar a query de forma que um único elemento de array atenda a essa condição ou qualquer combinação de elementos de array atenda às condições.

Fazer query de uma array com condições de filtro composto nos elementos da bandeja

O exemplo a seguir consulta documentos em que o array dim_cm contém elementos que, em alguma combinação, satisfazem as condições da query. Por exemplo, um elemento pode satisfazer a condição maior que 15 e outro elemento pode satisfazer a condição menor que 20, ou um único elemento pode satisfazer as duas:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

Array de query usando um filtro composto

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

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

Fazer query de um elemento de Array que atenda a vários critérios

Utilize o operador $elemMatch para especificar múltiplos critérios nos elementos de um array de forma que pelo menos um elemento de array satisfaça todos os critérios especificados.

O exemplo a seguir consulta documentos em que o array dim_cm contém pelo menos um elemento que é, ao mesmo tempo, maior que($gt) 22 e menor que($lt) 30:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

Array de query por várias condições

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

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

Fazer query de um elemento pela posição do índice da array

Usando notação de ponto, você pode especificar condições de query para um elemento em um determinado índice ou posição da array. A array usa indexação baseada em zero.

Observação

Ao fazer query com notação de ponto, o campo e o campo aninhado devem estar entre aspas.

O exemplo a seguir consulta todos os documentos em que o segundo elemento do array dim_cm é maior que 25:

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

Array de query por índice

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

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

Fazer query de uma array por comprimento da array

Use o operador $size para consultar arrays por número de elementos. Por exemplo, o seguinte seleciona documentos onde o array tags tem 3 elementos.

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

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

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

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

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

Fazer uma query de uma array com MongoDB Atlas

O exemplo nesta seção utiliza o conjunto de dados de filmes de amostra. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB Atlas, consulte Carregar Dados de Amostra.

Para fazer uma query de uma array no MongoDB Atlas, siga estas etapas:

1

Navegue até a coleção.

Na IU do MongoDB Atlas, clique em Database na barra lateral.
Para a implantação do banco de dados que contém os dados de amostra, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados sample_mflix.
Selecione a collection movies.

2

Especifique um documento de filtro de consulta.

Para consultar um documento que contenha um array, especifique um documento de filtro de query. Um documento de filtro de query usa operadores de query para especificar condições de pesquisa. Use os seguintes documentos de exemplo para consultar campos de array na collection sample_mflix.movies.

Para aplicar um filtro de query, copie um documento de exemplo na barra de pesquisa Filter e clique em Apply.

Para especificar uma condição de igualdade em uma array, utilize o documento de query { <field>: <value> } onde <value> é a array exata para corresponder, incluindo a ordem dos elementos. O exemplo seguinte encontra documentos que têm um campo genres que contém a array ["Action", "Comedy"] na ordem especificada:

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

Para localizar uma matriz que contenha ambos os elementos Action e Comedy, sem considerar a ordem ou outros elementos na array, utilize o operador $all:

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

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro { <field>: <value> } onde <value> é o valor do elemento.

As seguintes queries de exemplo para todos os documentos onde o campo genres contém a string Short como um de seus elementos:

{ genres: "Short" }

Para especificar condições sobre os elementos no campo de array, use operador de query no documento de filtro de query:

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

Por exemplo, a seguinte operação utiliza o operador $nin para consultar todos os documentos onde o campo genres não contém Drama.

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

Ao especificar condições compostas em elementos de array, você pode especificar a query de forma que um único elemento de array atenda a essa condição ou qualquer combinação de elementos de array atenda às condições.

Fazer query de uma array com condições de filtro composto nos elementos da bandeja

O exemplo a seguir consulta documentos em que a array cast contém elementos que, em alguma combinação, satisfazem as condições da query. Por exemplo, o filtro a seguir usa os operadores $regex e $eq para retornar documentos em que um único elemento de array termina em Olsen e outro elemento é igual a Mary-Kate Olsen ou um único elemento que satisfaça ambas as condições:

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

Esse filtro de query retorna filmes que incluem Mary-Kate Olsen em seu elenco e filmes que incluem Mary-Kate Olsen e Ashley Olsen em seu elenco.

Fazer query de um elemento de Array que atenda a vários critérios

Utilize o operador $elemMatch para especificar múltiplos critérios nos elementos de um array de forma que pelo menos um elemento de array satisfaça todos os critérios especificados.

O exemplo a seguir usa os operadores $elemMatch e $ne para fazer query de documentos em que a array languages contém pelo menos um elemento que não é null e não é igual a English.

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

Fazer query de um elemento pela posição do índice da array

Usando notação de ponto, você pode especificar condições de query para um elemento em um determinado índice ou posição da array. A array usa indexação baseada em zero.

Observação

Ao fazer query com notação de ponto, o campo e o campo aninhado devem estar entre aspas.

O exemplo a seguir utiliza o operador $ne para consultar todos os documentos em que o primeiro elemento no array countries não é igual a USA:

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

Fazer query de uma array por comprimento da array

Use o operador $size para consultar arrays por número de elementos. Por exemplo, o seguinte seleciona documentos onde o array genres tem 3 elementos.

{ genres: { $size: 3 } }

Tutoriais de consultas adicionais

Para exemplos de consulta adicionais, consulte:

Voltar

Documentos incorporados

Próximo

Arrays de documentos incorporados

Selecione a linguagem

Nesta página

Combine uma array
Fazer uma query de uma array para um elemento
Especificar várias condições para elementos de Array
Fazer uma query de uma array com MongoDB Atlas
Tutoriais de consultas adicionais