Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Consulta em documentos incorporados/aninhados

Nesta página

Fazer query em campo aninhado com notação de ponto

Combinar um documento incorporado/aninhado
Fazer query em documentos incorporados com o Atlas MongoDB
Tutoriais de consultas adicionais

Você pode consultar documentos incorporados no MongoDB com os métodos:

O driver da sua linguagem de programação.
A IU do MongoDB atlas. Para saber mais, consulte Fazer query de documentos incorporados 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 documentos incorporados/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 documentos incorporados/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 documentos inseridos/aninhados usando o método de MongoCollection.Find() no driver C# 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 documentos incorporados/aninhados 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 documentos incorporados/aninhados usando o método com.mongodb.reativestreams. cliente.MongoCollection.find no MongoDB Java Reative Streams 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 documentos incorporados/aninhados usando o método com.mongodb.client.MongoCollection.find no driver MongoDB Java Synchronous.

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 documentos incorporados/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 documentos incorporados/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 documentos incorporados/aninhados usando o método MongoDB::Collection::find() no Driver Perl 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 documentos incorporados/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 consulta em documentos incorporados/aninhados 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 documentos incorporados/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 documentos incorporados/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", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

[
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

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

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" } },
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

# 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",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'A'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]);

# 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",
            qty    => 25,
            size   => Tie::IxHash->new( h => 14, w => 21, uom => "cm" ),
            status => "A"
        },
        {
            item   => "notebook",
            qty    => 50,
            size   => Tie::IxHash->new( h => 8.5, w => 11, uom => "in" ),
            status => "A"
        },
        {
            item   => "paper",
            qty    => 100,
            size   => Tie::IxHash->new( h => 8.5, w => 11, uom => "in" ),
            status => "D"
        },
        {
            item   => "planner",
            qty    => 75,
            size   => Tie::IxHash->new( h => 22.85, w => 30, uom => "cm" ),
            status => "D"
        },
        {
            item   => "postcard",
            qty    => 45,
            size   => Tie::IxHash->new( h => 10, w => 15.25, uom => "cm" ),
            status => "A"
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'A',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);

# 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",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

client[:inventory].insert_many([
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'A' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' }
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

Fazer query em campo aninhado com notação de ponto

Para especificar uma condição de query em campos em um documento incorporado/aninhado, use notação de ponto ("field.nestedField").

Observação

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

Especificar correspondência de igualdade em um campo aninhado

O exemplo seguinte seleciona todos os documentos onde o campo uom aninhado no campo size é igual a "in":

db.inventory.find( { "size.uom": "in" } )

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

{ "size.uom": "in" }

var filter = Builders<BsonDocument>.Filter.Eq("size.uom", "in");
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"size.uom", "in"}},
)

findPublisher = collection.find(eq("size.uom", "in"));

findIterable = collection.find(eq("size.uom", "in"));

cursor = db.inventory.find({"size.uom": "in"})

const cursor = db.collection('inventory').find({
  'size.uom': 'in'
});

$cursor = $db->coll("inventory")->find( { "size.uom" => "in" } );

$cursor = $db->inventory->find(['size.uom' => 'in']);

cursor = db.inventory.find({"size.uom": "in"})

client[:inventory].find('size.uom' => 'in')

findObservable = collection.find(equal("size.uom", "in"))

Especifique a correspondência com o operador da consulta

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1>: { <operator1>: <value1> }, ... }

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1>: { <operator1>: <value1> }, ... }

Além do filtro de igualdade, o MongoDB fornece vários operadores de consulta para especificar as condições do filtro. Use os métodos do FilterDefinitionBuilder para criar um documento de filtro. Por exemplo:

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

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Por exemplo:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Por exemplo:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1>: { <operator1>: <value1> }, ... }

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1>: { <operator1>: <value1> }, ... }

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1> => { <operator1> => <value1> }, ... }

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

[ <field1> => [ <operator1> => <value1> ], ... ]

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1>: { <operator1>: <value1> }, ... }

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

{ <field1> => { <operator1> => <value1> }, ... }

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use os métodos auxiliares com.mongodb.client.model.Filters_ para facilitar a criação de documentos de filtro. Por exemplo:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

A consulta a seguir usa o operador menor que ($lt) no campo h incorporado no campo size:

db.inventory.find( { "size.h": { $lt: 15 } } )

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

{ "size.h": { $lt: 15 } }

var filter = Builders<BsonDocument>.Filter.Lt("size.h", 15);
var result = collection.Find(filter).ToList();

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

findPublisher = collection.find(lt("size.h", 15));

findIterable = collection.find(lt("size.h", 15));

cursor = db.inventory.find({"size.h": {"$lt": 15}})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 }
});

$cursor = $db->coll("inventory")->find( { "size.h" => { '$lt' => 15 } } );

$cursor = $db->inventory->find(['size.h' => ['$lt' => 15]]);

cursor = db.inventory.find({"size.h": {"$lt": 15}})

client[:inventory].find('size.h' => { '$lt' =>  15 })

findObservable = collection.find(lt("size.h", 15))

Especifique a condição `AND`

A consulta a seguir seleciona todos os documentos onde o campo aninhado h é menor do que 15, o campo aninhado uom é igual a "in" e o campo status é igual a "D":

db.inventory.find( { "size.h": { $lt: 15 }, "size.uom": "in", status: "D" } )

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

{ "size.h": { $lt: 15 }, "size.uom": "in", status: "D" }

Consultar vários campos aninhados

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Lt("size.h", 15), builder.Eq("size.uom", "in"), builder.Eq("status", "D"));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size.h", bson.D{
			{"$lt", 15},
		}},
		{"size.uom", "in"},
		{"status", "D"},
	})

findPublisher = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

findIterable = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 },
  'size.uom': 'in',
  status: 'D'
});

$cursor = $db->coll("inventory")->find(
    { "size.h" => { '$lt' => 15 }, "size.uom" => "in", status => "D" }
);

$cursor = $db->inventory->find([
    'size.h' => ['$lt' => 15],
    'size.uom' => 'in',
    'status' => 'D',
]);

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

client[:inventory].find('size.h'   => { '$lt' => 15 },
                        'size.uom' => 'in',
                        'status'   => 'D')

findObservable = collection.find(and(
  lt("size.h", 15),
  equal("size.uom", "in"),
  equal("status", "D")
))

Combinar um documento incorporado/aninhado

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field>: <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field>: <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, construa um filtro usando o método Eq:

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

<value> é o documento a ser correspondido.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro eq( <field1>, <value>), em que <value> é o documento a ser correspondido.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro eq( <field1>, <value>), em que <value> é o documento a ser correspondido.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field>: <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field>: <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field> => <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta [ <field> => <value> ], em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field>: <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro de consulta { <field> => <value> }, em que <value> é a consulta a ser correspondida.

Para especificar uma condição de igualdade em um campo que é um documento incorporado/aninhado, use o documento de filtro equal( <field1>, <value> ), em que <value> é o documento a ser correspondido.

Por exemplo, a query a seguir seleciona todos os documentos onde o campo size é igual ao documento { h: 14, w: 21, uom: "cm" }:

db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

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

{ size: { h: 14, w: 21, uom: "cm" } }

Consultar campo incorporado

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
	})

FindPublisher<Document> findPublisher = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

FindIterable<Document> findIterable = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

const cursor = db.collection('inventory').find({
  size: { h: 14, w: 21, uom: 'cm' }
});

# 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(
    { size => Tie::IxHash->new( h => 14, w => 21, uom => "cm" ) }
);

$cursor = $db->inventory->find(['size' => ['h' => 14, 'w' => 21, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

client[:inventory].find(size: { h: 14, w: 21, uom: 'cm' })

var findObservable = collection.find(equal("size", Document("h" -> 14, "w" -> 21, "uom" -> "cm")))

Aviso

O MongoDB não recomenda comparações em documentos incorporados porque as operações exigem uma correspondência exata do documento <value> especificado, incluindo a ordem dos campos.

Por exemplo, a seguinte query não corresponde a nenhum documento da coleção inventory:

db.inventory.find(  { size: { w: 21, h: 14, uom: "cm" } }  )

Consultar campo incorporado

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "w", 21 }, { "h", 14 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"w", 21},
			{"h", 14},
			{"uom", "cm"},
		}},
	})

findPublisher = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

findIterable = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

cursor = db.inventory.find({"size": SON([("w", 21), ("h", 14), ("uom", "cm")])})

const cursor = db.collection('inventory').find({
  size: { w: 21, h: 14, uom: 'cm' }
});

# 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(
    { size => Tie::IxHash->new( w => 21, h => 14, uom => "cm" ) }
);

$cursor = $db->inventory->find(['size' => ['w' => 21, 'h' => 14, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": SON([("w", 21), ("h", 14), ("uom", "cm")])})

client[:inventory].find(size: { h: 21, w: 14, uom: 'cm' })

findObservable = collection.find(equal("size", Document("w" -> 21, "h" -> 14, "uom" -> "cm")))

As consultas que usam comparações em documentos incorporados podem resultar em comportamento imprevisível quando usadas com um driver que não usa estruturas de dados ordenadas para expressar consultas.

Fazer query em documentos incorporados com o Atlas MongoDB

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 query em um documento incorporado 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 o documento do filtro de query

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

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

{ "awards.wins": 1 }

4

Clique em Apply

Esse filtro de query retorna todos os documentos na coleção sample_mflix.movies em que o documento incorporado para o campo awards contém { wins: 1 }.

Tutoriais de consultas adicionais

Para exemplos de consulta adicionais, consulte:

Voltar

Query

Próximo

arrays

Selecione a linguagem

Nesta página

Fazer query em campo aninhado com notação de ponto
Combinar um documento incorporado/aninhado
Fazer query em documentos incorporados com o Atlas MongoDB
Tutoriais de consultas adicionais