Menu Docs
Página inicial do Docs
/
Desenvolvimento
/
Operações CRUD
Página inicial do Docs
/
Desenvolvimento
/
Operações CRUD
Página inicial do Docs
/
Desenvolvimento
/
Operações CRUD

Consultar documentos

Para fazer query de documentos, especifique um predicado de query que indica quais documentos retornar. Um predicado de query vazio { } retorna todos os documentos na coleção.

Você pode consultar documentos no MongoDB com 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 utilizando o método db.collection.find() em mongosh.

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

Esta página fornece exemplos de operações de 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 mongoc_collection_find_with_opts.

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

Esta página fornece exemplos de operações de query usando o método MongoCollection.Find() no driver MongoDB C#.

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

Esta página fornece exemplos de operações de consulta 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 MongoCollection.find() no MongoDB Kotlin Coroutine Driver.

Dica

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

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

Esta página fornece exemplos de operações de query usando o método pymongo.asynchronous.collection.AsyncCollection.find na API PyMongo assíncrona.

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

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}
var documents = new 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 := []any{
	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' }")
));
collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14)
                .append("w", 21)
                .append("uom", "cm")
            )
            .append("status", "A"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5)
                .append("w", 11)
                .append("uom", "in")
            )
            .append("status", "A"),
        Document("item", "paper")
            .append("qty", 100)
            .append("size", Document("h", 8.5)
                .append("w", 11)
                .append("uom", "in")
            )
            .append("status", "D"),
        Document("item", "planner")
            .append("qty", 75)
            .append("size", Document("h", 22.85)
                .append("w", 30)
                .append("uom", "cm")
            )
            .append("status", "D"),
        Document("item", "postcard")
            .append("qty", 45)
            .append("size", Document("h", 10)
                .append("w", 15.25)
                .append("uom", "cm")
            )
            .append("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'
  }
]);
$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:

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
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (NULL);
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

Limpe quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

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());
val flowInsertMany = collection
    .find(empty())
cursor = db.inventory.find({})
const cursor = db.collection('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 query de {}, que corresponde à seguinte declaração SQL:

SELECT * FROM inventory

Para mais informações, consulte find().

Para mais informações, consulte Barra de Query.

Para mais informações, consulte mongoc_collection_find_with_opts.

Para mais informações, consulte Localizar().

Para obter mais informações, consulte Collection.Find.

Para mais informações, consulte com.mongodb. cliente.MongoCollection.find.

Para mais informações, consulte MongoCollection.find().

Para mais informações,find consulte.

Para mais informações, consulte encontrar().

Para obter mais informações, consulte find().

Para mais informações,find consulte.

Para mais informações, consulte encontrar().

Para mais informações, 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, utilize expressões <field>:<value> no documento do filtro de queries:

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

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

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

Para especificar condições de igualdade, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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, use o método Filters.eq() método 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 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 todos os documentos da collection inventory em que 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" }

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.

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("status", BCON_UTF8 ("D"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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"));
val findFlow = collection
    .find(eq("status", "D"))
cursor = db.inventory.find({"status": "D"})
const cursor = db.collection('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 query de { status: "D" }, que corresponde à seguinte declaração SQL:

SELECT * FROM inventory WHERE status = "D"

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

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 do filtro de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use o pacote BSON para criar operadores de query para documentos de filtro. Por exemplo:

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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" ] } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", "{",
   "$in", "[",
   BCON_UTF8 ("A"), BCON_UTF8 ("D"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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"));
val findFlow = 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->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 usar o operador nessa $or query, use o operador $in $or em vez de ao executar verificações de igualdade no mesmo campo.

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

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

Para obter a lista completa de operadores de query do MongoDB, consulte Predicados de query.

Especificar AND Condições

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 } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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)));
val findFlow = 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->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 query de { status: "A", qty: { $lt: 30 } }, que corresponde à seguinte declaração SQL:

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

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

Especificar OR Condições

Utilize o operador para especificar uma query composta que se junta a cada cláusula com uma $or conjunção OR lógica do. A query seleciona documentos que correspondam 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 } } ] }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "$or", "[",
   "{",
   "status", BCON_UTF8 ("A"),
   "}","{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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)));
val findFlow = 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->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 query de { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }, que corresponde à seguinte declaração SQL:

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

Observação

As queries com operadores de comparação estão sujeitas a Type Bracketing.

Especifique AND e também OR condições

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/ } ] }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "$or", "[",
   "{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}","{",
   "item", BCON_REGEX ("^p", ""),
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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")))
);
val findFlow = 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->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 consulta 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

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

Para projeto campos para uma query no MongoDB Atlas, siga estas etapas:

1

Na interface do usuário do MongoDB Atlas , vá para a Clusters página do seu projeto.

  1. Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.

  2. Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.

  3. Na barra lateral, clique em Clusters sob o título Database.

    A página Clusters é exibida.

2

Navegue até a coleção

  1. Para o cluster que contém os dados de amostra, clique em Browse Collections.

  2. No painel de navegação esquerdo, selecione o banco de dados sample_mflix.

  3. Selecione a collection movies.

3

Especifique o Filter campo

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

A query retorna todos os documentos na collection sample_mflix.movies onde o campo year corresponde a 1924.

Tutoriais de consultas adicionais

Para mais exemplos de query, consulte:

Comportamento

Cursor

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

A Find operação abre um cursor para os documentos correspondentes da collection com base na query de busca.

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

O método mongoc_collection_find_with_opts retorna um cursor para os documentos correspondentes.

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.

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

O método MongoCollection.find() retorna uma instância da classe FindFlow.

O método pymongo.asynchronous.collection.AsyncCollection.find retorna um cursor para os documentos correspondentes.

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 da biblioteca PHP do MongoDB para iterar sobre um cursor.

O método pymongo.collection.Collection.find retorna um cursor para os documentos correspondentes. Consulte 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.

Atualizações simultâneas ao usar um cursor

Enquanto um cursor retorna documentos, outras operações podem ser executadas em segundo plano e afetar os resultados, dependendo do nível da preocupação de leitura . Para obter detalhes, consulte Isolamento de leitura, consistência e recência.

Isolamento de leitura

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

Quando você executa uma operação de localizar com um driver MongoDB mongosh ou, o MongoDB retorna um cursor que gerencia os resultados da consulta. Os resultados da consulta não retornam como um array de documentos.

Para saber como iterar documentos em um cursor, consulte a documentação do motorista. Se você estiver utilizando mongosh o, consulte Iterar um cursor mongosh no.

Métodos e opções adicionais

Você também pode ler documentos de uma coleção com:

Observação

O métododb.collection.findOne()executa a mesma operação quedb.collection.find()com um limite de 1.

O MongoDB Compass também aceita as seguintes opções de barra de query:

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 de documentos a serem ignorados antes de retornar o conjunto de resultados.

Limite

Especifique o número máximo de documentos a retornar.

Você também pode ler documentos de uma coleção com:

Você também pode ler documentos de uma coleção com:

Observação

O método MongoCollection.FindOne() executa a mesma operação que MongoCollection.Find() com um limite 1 de.

Você também pode ler documentos de uma coleção com:

Você também pode ler documentos de uma coleção com o $match estágio de pipeline em um pipeline de agregação . Para obter mais informações, consulte os exemplos de aggregation de drivers assíncronos Java .

Você também pode ler documentos de uma coleção com o $match estágio de pipeline em um pipeline de agregação . Para obter mais informações, consulte os exemplos de aggregation de drivers Java síncronos.

Você também pode ler documentos de uma coleção com o $match estágio de pipeline em um pipeline de agregação . Para obter mais informações, consulte os exemplos de operação de localização de drivers do Kotlin Coroutine.

Você também pode ler documentos de uma coleção com:

Observação

O métodopymongo.asynchronous.collection.AsyncCollection.find_oneexecuta a mesma operação quepymongo.asynchronous.collection.AsyncCollection.findcom um limite de 1.

Você também pode ler documentos de uma coleção com:

Observação

O método Collection.findOne() executa a mesma operação que Collection.find() com um limite 1 de.

Você também pode ler documentos de uma coleção com:

Observação

O métodoMongoDB\\Collection::findOne()executa a mesma operação queMongoDB\\Collection::find()com um limite de 1.

Você também pode ler documentos de uma coleção com:

Observação

O método pymongo.collection.Collection.find_one executa a mesma operação que o método pymongo.collection.Collection.find com um limite de 1.

Você também pode ler documentos de uma coleção com o $match estágio de pipeline em um pipeline de agregação . Para obter mais informações, consulte os exemplos de agregação .

Você também pode ler documentos de uma coleção com o $match estágio de pipeline em um pipeline de agregação . Para obter mais informações, consulte o método agregado.

Voltar

Métodos

Próximo

Documentos incorporados

Receber um selo de habilidade

Domine "Otimização de Consultas" gratuitamente!

Saiba mais

Nesta página