Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Consultas em uma array de documentos incorporados

Nesta página

Fazer query para um documento aninhado em uma bandeja

Especifique uma condição de consulta em um campo em uma matriz de documentos
Especifique múltiplas condições para array de documentos
Consulta a uma matriz de documentos com o MongoDB Atlas
Tutoriais de consultas adicionais

Você pode consultar documentos no MongoDB usando os seguintes métodos:

O driver da sua linguagem de programação.
AIU de usuário do MongoDBAtlas. Para saber mais, consulte Fazer query de uma array de documentos 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 uma array de documentos aninhados 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 uma array de documentos aninhados usando 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 uma array de documentos aninhados usando o método 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 operações de consulta em uma variedade de documentos aninhados usando a Coleção.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 uma array de documentos aninhados 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 uma array de documentos aninhados 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 uma array de documentos aninhados 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 operações de query em um array de documentos aninhados usando o método 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 em uma array de documentos aninhados 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 uma array de documentos aninhados 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 query em uma array de documentos aninhados usando o no driver pymongo.collection.Collection.find 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 uma array de documentos aninhados 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 query em uma array de documentos aninhados usando o método 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", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
   { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
   { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
   { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

[
    { "item": "journal", "instock": [ { "warehouse": "A", "qty": 5 }, { "warehouse": "C", "qty": 15 } ] },
    { "item": "notebook", "instock": [ { "warehouse": "C", "qty": 5 } ] },
    { "item": "paper", "instock": [ { "warehouse": "A", "qty": 60 }, { "warehouse": "B", "qty": 15 } ] },
    { "item": "planner", "instock": [ { "warehouse": "A", "qty": 40 }, { "warehouse": "B", "qty": 5 } ] },
    { "item": "postcard", "instock": [ { "warehouse": "B","qty": 15 }, { "warehouse": "C", "qty": 35 } ] }
]

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

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 5 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 40 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
            }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "C"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 35},
			},
		}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "instock": [
                SON([("warehouse", "A"), ("qty", 5)]),
                SON([("warehouse", "C"), ("qty", 15)]),
            ],
        },
        {"item": "notebook", "instock": [SON([("warehouse", "C"), ("qty", 5)])]},
        {
            "item": "paper",
            "instock": [
                SON([("warehouse", "A"), ("qty", 60)]),
                SON([("warehouse", "B"), ("qty", 15)]),
            ],
        },
        {
            "item": "planner",
            "instock": [
                SON([("warehouse", "A"), ("qty", 40)]),
                SON([("warehouse", "B"), ("qty", 5)]),
            ],
        },
        {
            "item": "postcard",
            "instock": [
                SON([("warehouse", "B"), ("qty", 15)]),
                SON([("warehouse", "C"), ("qty", 35)]),
            ],
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    instock: [
      { warehouse: 'A', qty: 5 },
      { warehouse: 'C', qty: 15 }
    ]
  },
  {
    item: 'notebook',
    instock: [{ warehouse: 'C', qty: 5 }]
  },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 15 }
    ]
  },
  {
    item: 'planner',
    instock: [
      { warehouse: 'A', qty: 40 },
      { warehouse: 'B', qty: 5 }
    ]
  },
  {
    item: 'postcard',
    instock: [
      { warehouse: 'B', qty: 15 },
      { warehouse: 'C', qty: 35 }
    ]
  }
]);

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$db->coll("inventory")->insert_many(
    [
        {
            item    => "journal",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 5 ),
                Tie::IxHash->new( warehouse => "C", qty => 15 )
            ]
        },
        {
            item    => "notebook",
            instock => [ Tie::IxHash->new( warehouse => "C", qty => 5 ) ]
        },
        {
            item    => "paper",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 60 ),
                Tie::IxHash->new( warehouse => "B", qty => 15 )
            ]
        },
        {
            item    => "planner",
            instock => [
                Tie::IxHash->new( warehouse => "A", qty => 40 ),
                Tie::IxHash->new( warehouse => "B", qty => 5 )
            ]
        },
        {
            item    => "postcard",
            instock => [
                Tie::IxHash->new( warehouse => "B", qty => 15 ),
                Tie::IxHash->new( warehouse => "C", qty => 35 )
            ]
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 5],
            ['warehouse' => 'C',  'qty' => 15],
        ],
    ],
    [
        'item' => 'notebook',
        'instock' => [
            ['warehouse' => 'C',  'qty' => 5],
        ],
    ],
    [
        'item' => 'paper',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 60],
            ['warehouse' => 'B',  'qty' => 15],
        ],
    ],
    [
        'item' => 'planner',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 40],
            ['warehouse' => 'B',  'qty' => 5],
        ],
    ],
    [
        'item' => 'postcard',
        'instock' => [
            ['warehouse' => 'B',  'qty' => 15],
            ['warehouse' => 'C',  'qty' => 35],
        ],
    ],
]);

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "instock": [
                SON([("warehouse", "A"), ("qty", 5)]),
                SON([("warehouse", "C"), ("qty", 15)]),
            ],
        },
        {"item": "notebook", "instock": [SON([("warehouse", "C"), ("qty", 5)])]},
        {
            "item": "paper",
            "instock": [
                SON([("warehouse", "A"), ("qty", 60)]),
                SON([("warehouse", "B"), ("qty", 15)]),
            ],
        },
        {
            "item": "planner",
            "instock": [
                SON([("warehouse", "A"), ("qty", 40)]),
                SON([("warehouse", "B"), ("qty", 5)]),
            ],
        },
        {
            "item": "postcard",
            "instock": [
                SON([("warehouse", "B"), ("qty", 15)]),
                SON([("warehouse", "C"), ("qty", 35)]),
            ],
        },
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  instock: [ { warehouse: 'A', qty: 5 },
                                             { warehouse: 'C', qty: 15 }] },
                                { item: 'notebook',
                                  instock: [ { warehouse: 'C', qty: 5 }] },
                                { item: 'paper',
                                  instock: [ { warehouse: 'A', qty: 60 },
                                             { warehouse: 'B', qty: 15 }] },
                                { item: 'planner',
                                  instock: [ { warehouse: 'A', qty: 40 },
                                             { warehouse: 'B', qty: 5 }] },
                                { item: 'postcard',
                                  instock: [ { warehouse: 'B', qty: 15 },
                                             { warehouse: 'C', qty: 35 }] }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] }"""),
  Document("""{ item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] }"""),
  Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] }"""),
  Document("""{ item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] }"""),
  Document("""{ item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }""")
)).execute()

Fazer query para um documento aninhado em uma bandeja

O exemplo a seguir seleciona todos os documentos em que um elemento na array instock corresponde ao documento especificado:

db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )

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

{ "instock": { warehouse: "A", qty: 5 } }

var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "warehouse", "A" }, { "qty", 5 } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"warehouse", "A"},
			{"qty", 5},
		}},
	})

FindPublisher<Document> findPublisher = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));

FindIterable<Document> findIterable = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));

cursor = db.inventory.find({"instock": SON([("warehouse", "A"), ("qty", 5)])})

const cursor = db.collection('inventory').find({
  instock: { warehouse: 'A', qty: 5 }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { instock => Tie::IxHash->new( warehouse => "A", qty => 5 ) }
);

$cursor = $db->inventory->find(['instock' => ['warehouse' => 'A', 'qty' => 5]]);

cursor = db.inventory.find({"instock": SON([("warehouse", "A"), ("qty", 5)])})

client[:inventory].find(instock: { warehouse: 'A', qty: 5 })

var findObservable = collection.find(equal("instock", Document("warehouse" -> "A", "qty" -> 5)))

As correspondências de igualdade em todo o documento incorporado/aninhado exigem uma correspondência exata do documento especificado, incluindo a ordem dos campos. Por exemplo, a seguinte query não corresponde a nenhum documento da collection inventory:

db.inventory.find( { "instock": { qty: 5, warehouse: "A" } } )

var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"qty", 5},
			{"warehouse", "A"},
		}},
	})

findPublisher = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

findIterable = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

cursor = db.inventory.find({"instock": SON([("qty", 5), ("warehouse", "A")])})

const cursor = db.collection('inventory').find({
  instock: { qty: 5, warehouse: 'A' }
});

# Subdocument key order matters in this example so we have
# to use Tie::IxHash instead of a regular, unordered Perl hash.
$cursor = $db->coll("inventory")->find(
    { instock => Tie::IxHash->new( qty => 5, warehouse => "A" ) }
);

$cursor = $db->inventory->find(['instock' => ['qty' => 5, 'warehouse' => 'A']]);

cursor = db.inventory.find({"instock": SON([("qty", 5), ("warehouse", "A")])})

client[:inventory].find(instock: { qty: 5, warehouse: 'A' } )

findObservable = collection.find(equal("instock", Document("qty" -> 5, "warehouse" -> "A")))

Especifique uma condição de consulta em um campo em uma matriz de documentos

Especifique uma condição de consulta em um campo incorporado em uma matriz de documentos

Se você não souber a posição do índice do documento aninhado na array, concateneie o nome do campo da array, com um ponto (.) e o nome do campo no documento aninhado.

O exemplo a seguir seleciona todos os documentos em que a array instock tem pelo menos um documento incorporado que contém o campo qty cujo valor é menor ou igual a 20:

db.inventory.find( { 'instock.qty': { $lte: 20 } } )

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

{ 'instock.qty': { $lte: 20 } }

Fazer query de campo incorporado que corresponde a uma única condição

var filter = Builders<BsonDocument>.Filter.Lte("instock.qty", 20);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(lte("instock.qty", 20));

findIterable = collection.find(lte("instock.qty", 20));

cursor = db.inventory.find({"instock.qty": {"$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.qty': { $lte: 20 }
});

$cursor = $db->coll("inventory")->find( { 'instock.qty' => { '$lte' => 20 } } );

$cursor = $db->inventory->find(['instock.qty' => ['$lte' => 20]]);

cursor = db.inventory.find({"instock.qty": {"$lte": 20}})

client[:inventory].find('instock.qty' => { '$lte' => 20 })

findObservable = collection.find(lte("instock.qty", 20))

Use o índice de array para fazer query de um campo no documento incorporado

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

Observação

Ao consultar com notação de ponto, o campo e o índice devem estar entre aspas.

O exemplo a seguir seleciona todos os documentos onde a array instock tem como primeiro elemento um documento que contém o campo qty cujo valor é menor ou igual a 20:

db.inventory.find( { 'instock.0.qty': { $lte: 20 } } )

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

{ 'instock.0.qty': { $lte: 20 } }

Fazer query por elemento de array correspondente a uma única condição

var filter = Builders<BsonDocument>.Filter.Lte("instock.0.qty", 20);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.0.qty", bson.D{
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(lte("instock.0.qty", 20));

findIterable = collection.find(lte("instock.0.qty", 20));

cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.0.qty': { $lte: 20 }
});

$cursor = $db->coll("inventory")->find( { 'instock.0.qty' => { '$lte' => 20 } } );

$cursor = $db->inventory->find(['instock.0.qty' => ['$lte' => 20]]);

cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})

client[:inventory].find('instock.0.qty' => { '$lte' => 20 })

findObservable = collection.find(lte("instock.0.qty", 20))

Especifique múltiplas condições para array de documentos

Ao especificar condições em mais de um campo aninhado em uma matriz de documentos, você pode especificar a consulta de forma que um único documento atenda a essas condições ou que qualquer combinação de documentos (incluindo um único documento) na matriz atenda às condições.

Um único documento aninhado atende a várias condições de query em campos aninhados

Use $elemMatch operador para especificar vários critérios em uma array de documentos incorporados de modo que pelo menos um documento incorporado satisfaça todos os critérios especificados.

Os seguintes exemplos de consultas para documentos onde a matriz instock tem pelo menos um documento incorporado que contém o campo qty igual a 5 e o campo warehouse igual a A:

db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )

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

{ "instock": { $elemMatch: { qty: 5, warehouse: "A" } } }

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", 5},
				{"warehouse", "A"},
			}},
		}},
	})

findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})

const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: 5, warehouse: 'A' } }
});

$cursor = $db->coll("inventory")->find(
    { instock => { '$elemMatch' => { qty => 5, warehouse => "A" } } }
);

$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => 5, 'warehouse' => 'A']]]);

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})

client[:inventory].find(instock: { '$elemMatch' => { qty: 5,
                                                     warehouse: 'A' } })

findObservable = collection.find(elemMatch("instock", Document("qty" -> 5, "warehouse" -> "A")))

O exemplo a seguir query os documentos em que a array instock tem pelo menos um documento incorporado que contém o campo qty que é maior que 10 e menor ou igual a 20:

db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )

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

{ "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } }

var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", new BsonDocument { { "$gt", 10 }, { "$lte", 20 } } } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", bson.D{
					{"$gt", 10},
					{"$lte", 20},
				}},
			}},
		}},
	})

findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})

const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: { $gt: 10, $lte: 20 } } }
});

$cursor = $db->coll("inventory") ->find(
    { instock => { '$elemMatch' => { qty => { '$gt' => 10, '$lte' => 20 } } } }
);

$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => ['$gt' => 10, '$lte' => 20]]]]);

cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})

client[:inventory].find(instock: { '$elemMatch' => { qty: { '$gt'  => 10,
                                                            '$lte' => 20 } } })

findObservable = collection.find(elemMatch("instock", Document("""{ qty: { $gt: 10, $lte: 20 } }""")))

A combinação de elementos satisfaz os critérios

Se as condições da consulta composta de um campo da matriz não utilizarem o $elemMatch operador , a consulta selecionará os documentos cuja matriz contiver qualquer combinação de elementos que satisfaça as condições.

Por exemplo, a consulta a seguir corresponde a documentos em que todos os documentos aninhados da matriz instock contenham o campo qty maior que 10 e todos os documentos (mas não necessariamente o mesmo documento incorporado) da matriz contenham o campo qty menor ou igual a 20:

db.inventory.find( { "instock.qty": { $gt: 10,  $lte: 20 } } )

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

{ "instock.qty": { $gt: 10,  $lte: 20 } }

Consulte o valor da quantidade dentro do intervalo

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("instock.qty", 10), builder.Lte("instock.qty", 20));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$gt", 10},
			{"$lte", 20},
		}},
	})

findPublisher = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));

findIterable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));

cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})

const cursor = db.collection('inventory').find({
  'instock.qty': { $gt: 10, $lte: 20 }
});

$cursor = $db->coll("inventory")->find(
    { "instock.qty" => { '$gt' => 10, '$lte' => 20 } }
);

$cursor = $db->inventory->find(['instock.qty' => ['$gt' => 10, '$lte' => 20]]);

cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})

client[:inventory].find('instock.qty' => { '$gt' => 10, '$lte' => 20 })

findObservable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)))

As seguintes queries de exemplo para documentos onde a array instock tem pelo menos um documento incorporado que contém o campo qty igual a 5 e pelo menos um documento incorporado (mas não necessariamente o mesmo documento incorporado) que contém o campo warehouse igual a A:

db.inventory.find( { "instock.qty": 5, "instock.warehouse": "A" } )

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

{ "instock.qty": 5, "instock.warehouse": "A" }

Consulte a quantidade correspondente e a localização do armazém

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("instock.qty", 5), builder.Eq("instock.warehouse", "A"));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", 5},
		{"instock.warehouse", "A"},
	})

findPublisher = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));

findIterable = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));

cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})

const cursor = db.collection('inventory').find({
  'instock.qty': 5,
  'instock.warehouse': 'A'
});

$cursor = $db->coll("inventory")->find(
    { "instock.qty" => 5, "instock.warehouse" => "A" }
);

$cursor = $db->inventory->find(['instock.qty' => 5, 'instock.warehouse' => 'A']);

cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})

client[:inventory].find('instock.qty' => 5,
                        'instock.warehouse' => 'A')

findObservable = collection.find(and(equal("instock.qty", 5), equal("instock.warehouse", "A")))

Consulta a uma matriz de documentos com o MongoDB Atlas

O exemplo nesta seção utiliza o conjunto de dados de treinamento 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 query de uma array de documentos no MongoDB Atlas, siga estas etapas:

1

Na interface do usuário do MongoDB Atlas , vá para a Clusters página 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_training.
Selecione a collection grades.

3

Especifique o campo Filtro

Especifique o documento de filtro de consulta no campo Filter. Um documento de filtro de consulta usa operadores de consulta para especificar as condições de pesquisa.

Copie o seguinte documento de filtro de consulta para a barra de pesquisa Filter:

{"scores.type": "exam"}

4

Clique em Apply

Esse filtro de query retorna todos os documentos na coleção sample_training.grades que contêm um subdocumento na array scores em que type está definido como exam. O documento completo, incluindo toda a array scores , é retornado. Para obter mais informações sobre como modificar a array retornada, consulte Elementos de array específicos do projeto na array retornada.

Tutoriais de consultas adicionais

Para exemplos de consulta adicionais, consulte:

Voltar

arrays

Próximo

Resultados do projeto

Selecione a linguagem

Nesta página

Fazer query para um documento aninhado em uma bandeja
Especifique uma condição de consulta em um campo em uma matriz de documentos
Especifique múltiplas condições para array de documentos
Consulta a uma matriz de documentos com o MongoDB Atlas
Tutoriais de consultas adicionais