Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Consultas em uma array

Nesta página

Combine um array

Fazer uma query de um array para um elemento
Especificar várias condições para elementos de Array
Fazer uma query de um 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.
O MongoDB Atlas IU. 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 utilizando 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 mongoc_collection_find_with_opts.

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 matriz usando o método MongoCollection.find () no driver MongoDB C#.

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 a função Collection.Find 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 os métodos auxiliares com.mongodb.client.model.Filters 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 MongoCollection.find() no MongoDB Kotlin Coroutine Driver.

Dica

O driver fornece os métodos auxiliares com.mongodb.client.model.Filters 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 método motor.motor_asyncio.AsyncIOMotorCollection.find no driver Motor.

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 Driver Node.js 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 query com projeção usando o método 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 consulta em campos de matriz usando o método Mongo::Collection#find() no driver Ruby 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 collection.find() método 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.

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"), BCON_UTF8 ("plain"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_DOUBLE (22.85), BCON_INT64 (30),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "tags", "[",
   BCON_UTF8 ("blue"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (10), BCON_DOUBLE (15.25),
   "]");
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "tags", new BsonArray { "blank", "red" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "tags", new BsonArray { "red", "blank" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "tags", new BsonArray { "red", "blank", "plain" } },
        { "dim_cm", new BsonArray { 14, 21 } }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "tags", new BsonArray { "blank", "red" } },
        { "dim_cm", new BsonArray { 22.85, 30 } }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "tags", new BsonArray { "blue" } },
        { "dim_cm", new BsonArray { 10, 15.25 } }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"tags", bson.A{"blank", "red"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"tags", bson.A{"red", "blank"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"tags", bson.A{"red", "blank", "plain"}},
		{"dim_cm", bson.A{14, 21}},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"tags", bson.A{"blank", "red"}},
		{"dim_cm", bson.A{22.85, 30}},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"tags", bson.A{"blue"}},
		{"dim_cm", bson.A{10, 15.25}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
        Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"),
        Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"),
        Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }")
));

collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "notebook")
            .append("qty", 50)
            .append("tags", listOf("red", "blank"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "paper")
            .append("qty", 100)
            .append("tags", listOf("red", "blank", "plain"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "planner")
            .append("qty", 75)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(22.85, 30)),
        Document("item", "postcard")
            .append("qty", 45)
            .append("tags", listOf("blue"))
            .append("dim_cm", listOf(10, 15.25)),
    )
)

await db.inventory.insert_many(
    [
        {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
        {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
        {
            "item": "paper",
            "qty": 100,
            "tags": ["red", "blank", "plain"],
            "dim_cm": [14, 21],
        },
        {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
        {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    tags: ['blank', 'red'],
    dim_cm: [14, 21]
  },
  {
    item: 'notebook',
    qty: 50,
    tags: ['red', 'blank'],
    dim_cm: [14, 21]
  },
  {
    item: 'paper',
    qty: 100,
    tags: ['red', 'blank', 'plain'],
    dim_cm: [14, 21]
  },
  {
    item: 'planner',
    qty: 75,
    tags: ['blank', 'red'],
    dim_cm: [22.85, 30]
  },
  {
    item: 'postcard',
    qty: 45,
    tags: ['blue'],
    dim_cm: [10, 15.25]
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            qty    => 25,
            tags   => [ "blank", "red" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "notebook",
            qty    => 50,
            tags   => [ "red", "blank" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "paper",
            qty    => 100,
            tags   => [ "red", "blank", "plain" ],
            dim_cm => [ 14, 21 ]
        },
        {
            item   => "planner",
            qty    => 75,
            tags   => [ "blank", "red" ],
            dim_cm => [ 22.85, 30 ]
        },
        {
            item   => "postcard",
            qty    => 45,
            tags   => ["blue"],
            dim_cm => [ 10, 15.25 ]
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'tags' => ['blank', 'red'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'tags' => ['red', 'blank'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'tags' => ['red', 'blank', 'plain'],
        'dim_cm' => [14, 21],
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'tags' => ['blank', 'red'],
        'dim_cm' => [22.85, 30],
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'tags' => ['blue'],
        'dim_cm' => [10, 15.25],
    ],
]);

db.inventory.insert_many(
    [
        {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]},
        {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]},
        {
            "item": "paper",
            "qty": 100,
            "tags": ["red", "blank", "plain"],
            "dim_cm": [14, 21],
        },
        {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]},
        {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]},
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  qty: 25,
                                  tags: ['blank', 'red'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'notebook',
                                  qty: 50,
                                  tags: ['red', 'blank'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'paper',
                                  qty: 100,
                                  tags: ['red', 'blank', 'plain'],
                                  dim_cm: [ 14, 21 ] },
                                { item: 'planner',
                                  qty: 75,
                                  tags: ['blank', 'red'],
                                  dim_cm: [ 22.85, 30 ] },
                                { item: 'postcard',
                                  qty: 45,
                                  tags: ['blue'],
                                  dim_cm: [ 10, 15.25 ] }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }"""),
  Document("""{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }"""),
  Document("""{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }""")
)).execute()

Combine um 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 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 matriz, construa um filtro usando o Eq , onde <value> é a array exata a ser correspondida, incluindo a ordem dos elementos:

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

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 query do Compass e clique em Find:

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

Array de query exatamente correspondente

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

Se, em vez disso, você quiser encontrar um array que contenha os elementos "red" e "blank", sem levar em conta a ordem ou outros elementos do 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 correspondendo a todos os critérios

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "{",
   "$all", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

Fazer uma query de um 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, 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 , onde <value> é o valor do elemento a ser correspondido:

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

Para consultar se o campo de array contém pelo menos um elemento com o valor especificado, utilize o filtro eq( <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 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 fazer query e saber se o campo de array contém pelo menos um elemento com o valor especificado, use o filtro

{ <field> => <value> } em que 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 { <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 é um 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" }

Query de array correspondente a vários critérios

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("tags", BCON_UTF8 ("red"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

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 um array com condições de filtro composto nos elementos de array

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (15),
   "$lt", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20));
var result = collection.Find(filter).ToList();

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

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

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

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

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

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

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

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

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

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

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

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

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$elemMatch", "{",
   "$gt", BCON_INT64 (22),
   "$lt", BCON_INT64 (30),
   "}",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

Fazer query de um elemento pela posição do índice do 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 } }

Consultar array por índice

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm.1", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

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

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

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

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

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

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

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

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

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

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

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

Fazer query de um array por comprimento do 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 } }

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

Certifique-se também de limpar quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

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

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

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

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

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

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

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

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

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

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

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

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

Fazer uma query de um 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 Carregue dados de amostra.

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

1

Na IU do MongoDB Atlas, acesse a página Clusters do seu projeto.

Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se ainda não estiver exibido, clique em Clusters na barra lateral.
A página Clusters é exibida.

2

Navegue até a coleção.

Para o cluster 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.

3

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 coleção 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 um array com condições de filtro composto nos elementos de array

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

Este filtro de consulta 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 consultar 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 do 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 um array por comprimento do 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 um array
Fazer uma query de um array para um elemento
Especificar várias condições para elementos de Array
Fazer uma query de um array com MongoDB Atlas
Tutoriais de consultas adicionais