Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

Consultar documentos

Nesta página

Selecione todos os documentos de uma coleção

Especifique uma condição de igualdade
Especifique condições usando operadores de consulta
Especifique as condições AND
Especifique condições OR
Especifique condições AND e também OR
Fazer consulta de documentos com o MongoDB Atlas
Tutoriais de consultas adicionais
Comportamento
Métodos e opções adicionais

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

O driver da sua linguagem de programação.
A IU do MongoDB Atlas. Para saber mais, consulte Fazer consultas 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 consulta usando o métododb.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 consulta 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 usando o método 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 consulta 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 usando o método 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 utilizando o método com.mongodb.client.MongoCollection.find no Driver Java Synchronous 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 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 consulta 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 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 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 usando o método pymongo.collection.Collection.find no driver Python PyMongo.

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 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 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 BsonDocument[]
{
    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' }")
));

await db.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",
        },
    ]
)

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

$db->coll("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"
        }
    ]
);

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

db.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",
        },
    ]
)

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

Selecione todos os documentos de uma coleção

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro do filtro de queries para a barra de consulta. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

Para selecionar todos os documentos na coleção, passe um documento vazio como parâmetro de filtro de queries para o método de localização. O parâmetro do filtro de queries determina os critérios de seleção:

db.inventory.find( {} )

O Compass seleciona todos os documentos de uma coleção

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.Find(filter).ToList();

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

FindPublisher<Document> findPublisher = collection.find(new Document());

FindIterable<Document> findIterable = collection.find(new Document());

cursor = db.inventory.find({})

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

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

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

cursor = db.inventory.find({})

client[:inventory].find({})

var findObservable = collection.find(Document())

Esta operação usa um predicado de filtro {}, que corresponde à seguinte instrução SQL:

SELECT * FROM inventory

Para mais informações sobre a sintaxe do método, consulte find().

Para obter mais informações sobre a barra de consulta do MongoDB Compass, consulte Barra de consulta.

Para mais informações sobre a sintaxe do método, consulte Find().

Para mais informações sobre a sintaxe do método, consulte com.mongodb.reactivestreams.client.MongoCollection.find.

Para mais informações sobre a sintaxe do método, consulte com.mongodb.client.MongoCollection.find.

Para ver as opções compatíveis com o método find(), consulte find().

Para mais informações sobre a sintaxe do método, consulte find().

Para mais informações sobre a sintaxe do método, consulte find().

Para mais informações sobre a sintaxe do método, consulte find.

Para mais informações sobre a sintaxe do método, consulte find().

Para mais informações sobre a sintaxe do método, consulte collection.find().

Especifique uma condição de igualdade

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

O exemplo a seguir seleciona da coleção inventory todos os documentos em que o status é igual a "D":

db.inventory.find( { status: "D" } )

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

{ status: "D" }

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

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

findPublisher = collection.find(eq("status", "D"));

findIterable = collection.find(eq("status", "D"));

cursor = db.inventory.find({"status": "D"})

const cursor = db.collection('inventory').find({ status: 'D' });

$cursor = $db->coll("inventory")->find( { status => "D" } );

$cursor = $db->inventory->find(['status' => 'D']);

cursor = db.inventory.find({"status": "D"})

client[:inventory].find(status: 'D')

findObservable = collection.find(equal("status", "D"))

Esta operação usa um predicado de filtro { status: "D" }, que corresponde à seguinte instrução SQL:

SELECT * FROM inventory WHERE status = "D"

Observação

A barra de consulta do MongoDB Compass automaticamente preenche a consulta atual com base nas chaves nos documentos da sua coleção, incluindo chaves em subdocumentos incorporados.

Especifique condições usando operadores de 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>))

O exemplo seguinte recupera todos os documentos da coleção inventory onde status é igual a "A" ou "D":

db.inventory.find( { status: { $in: [ "A", "D" ] } } )

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

{ status: { $in: [ "A", "D" ] } }

var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}})

findPublisher = collection.find(in("status", "A", "D"));

findIterable = collection.find(in("status", "A", "D"));

cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})

const cursor = db.collection('inventory').find({
  status: { $in: ['A', 'D'] }
});

$cursor = $db->coll("inventory")->find( { status => { '$in' => [ "A", "D" ] } } );

$cursor = $db->inventory->find(['status' => ['$in' => ['A', 'D']]]);

cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})

client[:inventory].find(status: { '$in' => [ 'A', 'D' ]})

findObservable = collection.find(in("status", "A", "D"))

Observação

Embora você possa expressar esta consulta utilizando o operador $or, utilize o operador $in ao invés do operador $or ao executar verificações de igualdade no mesmo campo.

A operação usa um predicado de filtro de { status: { $in: [ "A", "D" ] } }, que corresponde à seguinte instrução SQL:

SELECT * FROM inventory WHERE status in ("A", "D")

Consulte o documento Operadores de consulta e projeção para obter a lista completa de operadores de consulta MongoDB.

Especifique as condições `AND`

Uma consulta composta pode especificar condições para mais de um campo nos documentos da coleção. Implicitamente, uma conjunção lógica do AND conecta as cláusulas de uma consulta composta para que a consulta selecione os documentos na coleção que correspondem a todas as condições.

O exemplo a seguir recupera todos os documentos na coleção inventory onde o status é igual a "A" e qty é menor que ($lt) 30:

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

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

{ status: "A", qty: { $lt: 30 } }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"qty", bson.D{{"$lt", 30}}},
	})

findPublisher = collection.find(and(eq("status", "A"), lt("qty", 30)));

findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));

cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})

const cursor = db.collection('inventory').find({
  status: 'A',
  qty: { $lt: 30 }
});

$cursor = $db->coll("inventory")->find( { status => "A", qty => { '$lt' => 30 } } );

$cursor = $db->inventory->find([
    'status' => 'A',
    'qty' => ['$lt' => 30],
]);

cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})

client[:inventory].find(status: 'A', qty: { '$lt' => 30 })

findObservable = collection.find(and(equal("status", "A"), lt("qty", 30)))

A operação usa um predicado de filtro de { status: "A", qty: { $lt: 30 } }, que corresponde à seguinte instrução SQL:

SELECT * FROM inventory WHERE status = "A" AND qty < 30

Consulte Operadores de comparação para outros operadores de comparação do MongoDB.

Especifique as condições `OR`

Usando o operador $or, você pode especificar uma consulta composta que une cada cláusula com uma conjunção lógica OR para que a consulta selecione os documentos na coleção que correspondem a pelo menos uma condição.

O exemplo a seguir recupera todos os documentos na coleção em que o status é igual a "A" ou qty é menor que ($lt) 30:

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

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

{ $or: [ { status: "A" }, { qty: { $lt: 30 } } ] }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"$or",
			bson.A{
				bson.D{{"status", "A"}},
				bson.D{{"qty", bson.D{{"$lt", 30}}}},
			}},
	})

findPublisher = collection.find(or(eq("status", "A"), lt("qty", 30)));

findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));

cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})

const cursor = db.collection('inventory').find({
  $or: [{ status: 'A' }, { qty: { $lt: 30 } }]
});

$cursor = $db->coll("inventory")->find(
    { '$or' => [ { status => "A" }, { qty => { '$lt' => 30 } } ] }
);

$cursor = $db->inventory->find([
    '$or' => [
        ['status' => 'A'],
        ['qty' => ['$lt' => 30]],
    ],
]);

cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})

client[:inventory].find('$or' => [{ status: 'A' },
                                  { qty: { '$lt' => 30 } }
                                 ])

findObservable = collection.find(or(equal("status", "A"), lt("qty", 30)))

A operação usa um predicado de filtro de { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }, que corresponde à seguinte instrução SQL:

SELECT * FROM inventory WHERE status = "A" OR qty < 30

Observação

As consultas que usam operadores de comparação estão sujeitas a Type Bracketing.

Especifique as condições `AND` e `OR`

No exemplo a seguir, a consulta composta seleciona todos os documentos na coleção em que o status é igual a "A" e qty é menor que ($lt) 30 ou item começa com o caractere p:

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

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

{ status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] }

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(
    builder.Eq("status", "A"),
    builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p"))));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"$or", bson.A{
			bson.D{{"qty", bson.D{{"$lt", 30}}}},
			bson.D{{"item", bson.Regex{Pattern: "^p", Options: ""}}},
		}},
	})

findPublisher = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);

findIterable = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);

cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)

const cursor = db.collection('inventory').find({
  status: 'A',
  $or: [{ qty: { $lt: 30 } }, { item: { $regex: '^p' } }]
});

$cursor = $db->coll("inventory")->find(
    {
        status => "A",
        '$or'  => [ { qty => { '$lt' => 30 } }, { item => { '$regex' => "^p" } } ]
    }
);

$cursor = $db->inventory->find([
    'status' => 'A',
    '$or' => [
        ['qty' => ['$lt' => 30]],
        // Alternatively: ['item' => new \MongoDB\BSON\Regex('^p')]
        ['item' => ['$regex' => '^p']],
    ],
]);

cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)

client[:inventory].find(status: 'A',
                        '$or' => [{ qty: { '$lt' => 30 } },
                                  { item: { '$regex' => BSON::Regexp::Raw.new('^p') } }
                        ])

findObservable = collection.find(and(
  equal("status", "A"),
  or(lt("qty", 30), regex("item", "^p")))
)

A operação utiliza um predicado de filtro de:

{
   status: 'A',
   $or: [
     { qty: { $lt: 30 } }, { item: { $regex: '^p' } }
   ]
}

que corresponde à seguinte declaração SQL:

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

Observação

O MongoDB suporta expressões regulares de consulta $regex para executar combinações de padrões de string.

Fazer consulta de documentos com o 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 projetar campos para retornar de uma consulta no MongoDB Atlas, siga estas etapas:

1

Na IU do MongoDB Atlas, acesse a Clusters página do seu projeto.<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

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 campo Filter

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:

{ year: 1924 }

4

Clique em Apply

Este filtro de queries retorna todos os documentos na coleção sample_mflix.movies onde o campo year corresponde a 1924.

Tutoriais de consultas adicionais

Para exemplos de consulta adicionais, consulte:

Comportamento

Cursor

O método db.collection.find() retorna um cursor para os documentos correspondentes.

A operação Find do MongoDB Compass abre um cursor para os documentos correspondentes da coleção com base na consulta "find".

Para obter mais informações sobre amostragem no MongoDB Compass, consulte as Perguntas frequentes do Compass.

O método MongoCollection.Find() retorna um cursor para os documentos correspondentes. Consulte a documentação do driver C# do MongoDB para iterar sobre um cursor.

A função Collection.Find retorna um Cursor para os documentos correspondentes. Veja a documentação do cursor para mais informações.

com.mongodb.reactivestreams.client.MongoCollection.find retorna uma instância da interface com.mongodb.reactivestreams.client.FindPublisher.

O método com.mongodb.client.MongoCollection.find retorna uma instância da interface com.mongodb.client.FindIterable.

O método Collection.find() retorna um cursor.

O método MongoDB::Collection::find() retorna um cursor para os documentos correspondentes. Consulte a documentação do driver MongoDB Perl sobre como iterar sobre um cursor.

O método MongoDB\\Collection::find() retorna um cursor para os documentos correspondentes. Consulte a documentação da biblioteca PHP do MongoDB para iterar sobre um cursor.

O método pymongo.collection.Collection.find retorna um cursor para os documentos correspondentes. Veja a documentação do PyMongo para iterar sobre um cursor.

O método Mongo::Collection#find() retorna um CollectionView, que é um Enumerable. Um Cursor é criado quando o View é enumerado; por exemplo, chamando #to_a() ou #each(). Você também pode obter um Enumerator ligando para #to_enum() no View. Consulte a documentação da API do driver Ruby sobre como iterar sobre um cursor.

O método collection.find() retorna o find Observable.

Isolamento de leitura

Novo na versão 3.2.

Para leituras de conjuntos de réplicas e fragmentos de conjuntos de réplicas, a preocupação de leitura permite que os clientes escolham um nível de isolamento para suas leituras. Para obter mais informações, consulte Ler preocupação.

Formato do resultado da consulta

Ao executar uma operação find com um driver MongoDB ou mongosh, o comando retorna um cursor que gerencia os resultados da consulta. Os resultados da consulta não retornam como uma array de documentos.

Para saber como iterar documentos em um cursor, consulte a documentação do driver. Se estiver usando o mongosh, consulte Iterar um cursor em mongosh.

Métodos e opções adicionais

Os métodos a seguir também podem ler documentos de uma coleção:

db.collection.findOne()
No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB.

Observação

O método db.collection.findOne() também executa uma operação de leitura para retornar um único documento. Internamente, o método db.collection.findOne() é o método db.collection.find() com um limite de 1.

Além do filter, o MongoDB Compass permite que as seguintes opções sejam passadas para a barra de consulta:

Projeto	Especifique quais campos retornar nos dados resultantes.
Sort	Especifique a ordem de classificação dos documentos devolvidos.
Ignorar	Especifique o primeiro número n do documento a ser ignorado antes de retornar o conjunto de resultados.
Limite	Especifique o número máximo de documentos a retornar.

Os métodos a seguir também podem ler documentos de uma coleção:

MongoCollection.FindOne()
No pipeline de agregação, o estágio de pipeline $match fornece acesso às queries do MongoDB. Consulte a documentação LINQ do driver MongoDB C#.

Observação

O método MongoCollection.FindOne() também executa uma operação de leitura para retornar um único documento. Internamente, o método MongoCollection.FindOne() é o método MongoCollection.Find() com um limite de 1.

Os métodos a seguir também podem ler documentos de uma coleção:

Collection.FindOne
No pipeline de agregação, o estágio de pipeline $match fornece acesso às queries do MongoDB. Consulte Collection.Aggregate.

Os métodos a seguir também podem ler documentos de uma coleção:

No pipeline de agregação, o estágio de pipeline $match fornece acesso às queries do MongoDB. Consulte com.mongodb.reactivestreams.client.MongoCollection.agregado Para maiores informações.

Os métodos a seguir também podem ler documentos de uma coleção:

No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB. Veja os exemplos de agregação do driver Java Synchronous.

Os métodos a seguir também podem ler documentos de uma coleção:

Collection.findOne()
No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB. Consulte o tutorial de agregaçãodo driver do MongoDB Node.js.

Observação

O método Collection.findOne() também executa uma operação de leitura para retornar um único documento. Internamente, o método Collection.findOne() é o método Collection.find() com um limite de 1.

Os métodos a seguir também podem ler documentos de uma coleção:

MongoDB::Collection::find_one()
No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB. Veja os exemplos de agregaçãodo driver Perl do MongoDB.

Observação

O método MongoDB::Collection::find_one() também executa uma operação de leitura para retornar um único documento. Internamente, o método MongoDB::Collection::find_one() é o método MongoDB::Collection::find() com um limite de 1.

Os métodos a seguir também podem ler documentos de uma coleção:

MongoDB\\Collection::findOne()
No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB. Consulteo exemplo de agregação da biblioteca PHP do MongoDB.

Observação

O método MongoDB\\Collection::findOne() também executa uma operação de leitura para retornar um único documento. Internamente, o método MongoDB\\Collection::findOne() é o método MongoDB\\Collection::find() com um limite de 1.

Os métodos a seguir também podem ler documentos de uma coleção:

pymongo.collection.Collection.find_one
No pipeline de agregação, o estágio de pipeline $match fornece acesso às consultas do MongoDB. Veja os exemplos de agregação do PyMongo.

Observação

O método pymongo.collection.Collection.find_one também executa uma operação de leitura para retornar um único documento. Internamente, o método pymongo.collection.Collection.find_one é o método pymongo.collection.Collection.find com um limite de 1.

Os métodos a seguir também podem ler documentos de uma coleção:

No pipeline de agregação, o estágio de pipeline $match fornece acesso às queries do MongoDB. Veja os exemplos de agregação do driver Ruby do MongoDB.

Os métodos a seguir também podem ler documentos de uma coleção:

No pipeline de agregação, o estágio de pipeline $match fornece acesso às queries do MongoDB. Consulte o método aggregate do driver Scala do MongoDB.

Voltar

Métodos

Próximo

Documentos incorporados

Selecione a linguagem

Nesta página

Selecione todos os documentos de uma coleção
Especifique uma condição de igualdade
Especifique condições usando operadores de consulta
Especifique condições AND
Especifique condições OR
Especifique condições AND e também OR
Fazer consulta de documentos com o MongoDB Atlas
Tutoriais de consultas adicionais
Comportamento
Métodos e opções adicionais