Menu Docs
Página inicial do Docs
/
Começar com Guias

Ler dados usando operadores e queries compostas

No guia de leitura anterior, Ler dados do MongoDB com queries , você leu dados usando queries de igualdade. Neste guia, você:

  • Leia os dados da collection sample_guides.planets com os operadores de comparação do MongoDB.

  • Combine critérios de queries para fazer queries compostas.

  • Use notação de ponto para consultar campos incorporados.

Tempo necessário: 20 minutos

Neste exercício, você lerá dados usando operadores de comparação.

1

Dica

Veja a seguir um esboço com o código mínimo necessário para se conectar ao MongoDB. Você fará adições nas próximas etapas para ler os dados.

Na linha 5, substitua a string URI por sua própria connection string Atlas.

CrudRead.cs
1using MongoDB.Bson;
2using MongoDB.Driver;
3
4// Replace the uri string with your MongoDB deployment's connection string.
5var uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
6
7var client = new MongoClient(uri);
8
9var coll = client.GetDatabase("sample_guides").GetCollection<BsonDocument>("planets");
10// find code goes here
11var cursor = coll.AsQueryable();
12
13foreach (var document in cursor)
14{
15 Console.WriteLine(document);
16}

Dica

Veja a seguir um esboço com o código mínimo necessário para se conectar ao MongoDB. Você fará adições nas próximas etapas para ler os dados.

Na linha 13, substitua a string URI por sua própria string de conexão Atlas .

crudRead.go
1package main
2
3import (
4 "context"
5 "fmt"
6
7 "go.mongodb.org/mongo-driver/bson"
8 "go.mongodb.org/mongo-driver/mongo"
9 "go.mongodb.org/mongo-driver/mongo/options"
10)
11
12func main() {
13 uri := "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
14
15 client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
16 if err != nil {
17 panic(err)
18 }
19
20 defer func() {
21 if err = client.Disconnect(context.TODO()); err != nil {
22 panic(err)
23 }
24 }()
25 coll := client.Database("sample_guides").Collection("planets")
26
27 // find code goes here
28 filter := bson.D{{}}
29 cursor, err := coll.Find(context.TODO(), filter)
30 if err != nil {
31 panic(err)
32 }
33
34 for cursor.Next(context.TODO()) {
35 var result bson.M
36 if err := cursor.Decode(&result); err != nil {
37 panic(err)
38 }
39 fmt.Println(result)
40 }
41 if err := cursor.Err(); err != nil {
42 panic(err)
43 }
44}

Dica

Veja a seguir um esboço com o código mínimo necessário para se conectar ao MongoDB. Você fará adições nas próximas etapas para ler os dados.

Na linha 8, substitua a string URI por sua própria string de conexão Atlas .

CrudRead.java
1import com.mongodb.client.*;
2import com.mongodb.client.model.Filters.*;
3import org.bson.Document;
4import org.bson.conversions.Bson;
5
6public class CrudRead {
7 public static void main(String[] args) {
8 String uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
9
10 try (MongoClient mongoClient = MongoClients.create(uri)) {
11 MongoCollection<Document> coll = mongoClient.getDatabase("sample_guides")
12 .getCollection("planets");
13 // find code goes here
14 Bson filter = Filters.empty();
15 MongoCursor<Document> cursor = coll.find(filter).iterator();
16 try {
17 while (cursor.hasNext()) {
18 System.out.println(cursor.next().toJson());
19 }
20 } finally {
21 cursor.close();
22 }
23 }
24 }
25}

Dica

Veja a seguir um esboço com o código mínimo necessário para se conectar ao MongoDB. Você fará adições nas próximas etapas para ler os dados.

Na linha 4, substitua a string URI pela sua própria connection string do Atlas.

crud-read.js
1const { MongoClient } = require("mongodb");
2// Replace the uri string with your MongoDB deployment's connection string.
3const uri =
4 "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
5const client = new MongoClient(uri);
6async function run() {
7 try {
8 await client.connect();
9 const coll = client.db("sample_guides").collection("planets");
10
11 // find code goes here
12 let cursor = coll.find();
13
14 await cursor.forEach(console.log);
15 } finally {
16 // Ensures that the client will close when you finish/error
17 await client.close();
18 }
19}
20run().catch(console.dir);

Dica

Veja a seguir um esboço com o código mínimo necessário para se conectar ao MongoDB. Você fará adições nas próximas etapas para ler os dados.

Na linha 4, substitua a string URI pela sua própria connection string do Atlas.

crud_read.py
1from pymongo import MongoClient
2
3# Replace the uri string with your MongoDB deployment's connection string.
4uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
5
6client = MongoClient(uri)
7coll = client.sample_guides.planets
8
9# find code goes here
10cursor = coll.find()
11
12for doc in cursor:
13 print(doc)
14
15# Close the connection to MongoDB when you're done.
16client.close()

Dica

MongoDB+srv

Certifique-se de ter instalado o PyMongo com a opção srv.

python3 -m pip install "pymongo[srv]"
2

Use a notação de ponto de ponto nessa consulta para selecionar documentos em que o documento incorporado surfaceTemperatureC tenha um valor em seu campo mean menor que 15 graus (Celsius).

CrudRead.cs
// find code goes here
var cursor = from planet in coll.AsQueryable()
where planet["surfaceTemperatureC.mean"] < 15
select planet;
crudRead.go
1// find code goes here
2filter := bson.D{{"surfaceTemperatureC.mean", bson.D{{"$lt", 15}}}}
3cursor, err := coll.Find(context.TODO(), filter)
4if err != nil {
5 panic(err)
6}

O driver Java do MongoDB inclui construtores que simplificam o processo de criação de query (e outras operações). Aqui, você usa o construtor Filters.lt para construir o documento de query.

CrudRead.java
1// find code goes here
2Bson filter = lt("surfaceTemperatureC.mean", 15);
3MongoCursor<Document> cursor = coll.find(filter).iterator();
crud-read.js
// find code goes here
const cursor = coll.find({ "surfaceTemperatureC.mean": { $lt: 15 } });
crud_read.py
# find code goes here
cursor = coll.find({"surfaceTemperatureC.mean": {"$lt": 15}})
3

Veja o código completo, seguido pela amostra de saída. Os resultados foram truncados para fins de exibição.

CrudRead.cs
1using MongoDB.Bson;
2using MongoDB.Driver;
3
4// Replace the uri string with your MongoDB deployment's connection string.
5var uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
6
7var client = new MongoClient(uri);
8
9var coll = client.GetDatabase("sample_guides").GetCollection<BsonDocument>("planets");
10// find code goes here
11var cursor = from planet in coll.AsQueryable()
12 where planet["surfaceTemperatureC.mean"] < 15
13 select planet;
14
15foreach (var document in cursor)
16{
17 Console.WriteLine(document);
18}
{ "name" : "Uranus", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -197.19999999999999 }, ... }
{ "name" : "Mars", "surfaceTemperatureC" : { "min" : -143, "max" : 35, "mean" : -63 }, ... }
{ "name" : "Neptune", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -201 }, ... }
{ "name" : "Jupiter", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -145.15000000000001 }, ... }
{ "name" : "Earth", "surfaceTemperatureC" : { "min" : -89.200000000000003, "max" : 56.700000000000003, "mean" : 14 }, ... }
{ "name" : "Saturn", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -139.15000000000001 }, ... }
crudRead.go
1package main
2
3import (
4 "context"
5 "fmt"
6
7 "go.mongodb.org/mongo-driver/bson"
8 "go.mongodb.org/mongo-driver/mongo"
9 "go.mongodb.org/mongo-driver/mongo/options"
10)
11
12func main() {
13 uri := "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
14
15 client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
16 if err != nil {
17 panic(err)
18 }
19
20 defer func() {
21 if err = client.Disconnect(context.TODO()); err != nil {
22 panic(err)
23 }
24 }()
25 coll := client.Database("sample_guides").Collection("planets")
26
27 // find code goes here
28 filter := bson.D{{"surfaceTemperatureC.mean", bson.D{{"$lt", 15}}}}
29 cursor, err := coll.Find(context.TODO(), filter)
30 if err != nil {
31 panic(err)
32 }
33
34 for cursor.Next(context.TODO()) {
35 var result bson.M
36 if err := cursor.Decode(&result); err != nil {
37 panic(err)
38 }
39 fmt.Println(result)
40 }
41 if err := cursor.Err(); err != nil {
42 panic(err)
43 }
44}
map[ name:Uranus surfaceTemperatureC:map[max:<nil> mean:-197.2 min:<nil>] ...]
map[ name:Mars surfaceTemperatureC:map[max:35 mean:-63 min:-143] ... ]
map[ name:Neptune surfaceTemperatureC:map[max:<nil> mean:-201 min:<nil>] ... ]
map[ name:Jupiter surfaceTemperatureC:map[max:<nil> mean:-145.15 min:<nil>] ... ]
map[ name:Earth surfaceTemperatureC:map[max:56.7 mean:14 min:-89.2]]
map[ name:Saturn surfaceTemperatureC:map[max:<nil> mean:-139.15 min:<nil>] ... ]
CrudRead.java
1import com.mongodb.client.*;
2import com.mongodb.client.model.Filters.*;
3import org.bson.Document;
4import org.bson.conversions.Bson;
5
6public class CrudRead {
7 public static void main(String[] args) {
8 String uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
9
10 try (MongoClient mongoClient = MongoClients.create(uri)) {
11 MongoCollection<Document> coll = mongoClient.getDatabase("sample_guides")
12 .getCollection("planets");
13
14 // find code goes here
15 Bson filter = lt("surfaceTemperatureC.mean", 15);
16 MongoCursor<Document> cursor = coll.find(filter).iterator();
17
18 // iterate code goes here
19 try {
20 while (cursor.hasNext()) {
21 System.out.println(cursor.next().toJson());
22 }
23 } finally {
24 cursor.close();
25 }
26 }
27 }
28}
{ "name" : "Uranus", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -197.19999999999999 }, ... }
{ "name" : "Mars", "surfaceTemperatureC" : { "min" : -143, "max" : 35, "mean" : -63 }, ... }
{ "name" : "Neptune", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -201 }, ... }
{ "name" : "Jupiter", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -145.15000000000001 }, ... }
{ "name" : "Earth", "surfaceTemperatureC" : { "min" : -89.200000000000003, "max" : 56.700000000000003, "mean" : 14 }, ... }
{ "name" : "Saturn", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -139.15000000000001 }, ... }
crud-read.js
1const { MongoClient } = require("mongodb");
2// Replace the uri string with your MongoDB deployment's connection string.
3const uri =
4 "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
5const client = new MongoClient(uri);
6async function run() {
7 try {
8 await client.connect();
9 const coll = client.db("sample_guides").collection("planets");
10
11 // find code goes here
12 const cursor = coll.find({ "surfaceTemperatureC.mean": { $lt: 15 } });
13
14 await cursor.forEach(console.log);
15 } finally {
16 // Ensures that the client will close when you finish/error
17 await client.close();
18 }
19}
20run().catch(console.dir);
{ "name" : "Uranus", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -197.19999999999999 }, ... }
{ "name" : "Mars", "surfaceTemperatureC" : { "min" : -143, "max" : 35, "mean" : -63 }, ... }
{ "name" : "Neptune", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -201 }, ... }
{ "name" : "Jupiter", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -145.15000000000001 }, ... }
{ "name" : "Earth", "surfaceTemperatureC" : { "min" : -89.200000000000003, "max" : 56.700000000000003, "mean" : 14 }, ... }
{ "name" : "Saturn", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -139.15000000000001 }, ... }
crud_read.py
1from pymongo import MongoClient
2
3# Replace the uri string with your MongoDB deployment's connection string.
4uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
5
6client = MongoClient(uri)
7coll = client.sample_guides.planets
8
9# find code goes here
10cursor = coll.find({"surfaceTemperatureC.mean": {"$lt": 15}})
11
12for doc in cursor:
13 print(doc)
14
15# Close the connection to MongoDB when you're done.
16client.close()
{ "name" : "Uranus", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -197.19999999999999 }, ... }
{ "name" : "Mars", "surfaceTemperatureC" : { "min" : -143, "max" : 35, "mean" : -63 }, ... }
{ "name" : "Neptune", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -201 }, ... }
{ "name" : "Jupiter", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -145.15000000000001 }, ... }
{ "name" : "Earth", "surfaceTemperatureC" : { "min" : -89.200000000000003, "max" : 56.700000000000003, "mean" : 14 }, ... }
{ "name" : "Saturn", "surfaceTemperatureC" : { "min" : null, "max" : null, "mean" : -139.15000000000001 }, ... }

Agora você lerá dados do MongoDB usando uma lógica E e OU para formar queries compostas.

1

Para gravar uma query composta no MongoDB que corresponda a todos os predicados de query (p. ex., um E lógico), especifique todos os campos que você deseja corresponder no documento de localização. Por padrão, o MongoDB corresponde todos os campos. Se seguiu o guia anterior, você já fez isso!

O exemplo a seguir recupera todos os documentos na collection planets onde o campo surfaceTemperatureC.mean é menor que 15 e o campo surfaceTemperatureC.min é maior que -100.

CrudRead.cs
1// find code goes here
2var cursor = from planet in coll.AsQueryable()
3 where planet["surfaceTemperatureC.mean"] < 15 && planet["surfaceTemperatureC.min"] > -100
4 select planet;
5
{'name': 'Earth', 'orderFromSun': 3, ...}
crudRead.go
1// find code goes here
2filter := bson.D{
3 {"$and",
4 bson.A{
5 bson.D{{"surfaceTemperatureC.mean",
6 bson.D{{"$lt", 15}},
7 }},
8 bson.D{{"surfaceTemperatureC.min",
9 bson.D{{"$gt", -100}},
10 }},
11 },
12 },
13}
14cursor, err := coll.Find(context.TODO(), filter)
15if err != nil {
16 panic(err)
17}
map[name:Earth orderFromSun:3 ...]
CrudRead.java
1// find code goes here
2Bson filter = and(lt("surfaceTemperatureC.mean", 15), gt("surfaceTemperatureC.min", -100));
3MongoCursor<Document> cursor = coll.find(filter).iterator();
{'name': 'Earth', 'orderFromSun': 3, ...}
crud-read.js
1// find code goes here
2const cursor = coll.find({
3 "surfaceTemperatureC.mean": { $lt: 15 },
4 "surfaceTemperatureC.min": { $gt: -100 },
5});
{'name': 'Earth', 'orderFromSun': 3, ...}

Observação

Implícito E

Especificar vários critérios é comum. Se você não especificar nenhum operador de query, o driver interpreta seus critérios de forma "E". No entanto, às vezes, você deve ser explícito ao especificar vários critérios, especialmente ao especificar critérios no mesmo campo.

Por exemplo, para localizar documentos na collection planets que tenham um valor de orderFromSun maior que 2 E menor que 5, você deve usar o operador de query $and .

crud-read.js
1const cursor = coll.find({
2 $and: [{ orderFromSun: { $gt: 2 } }, { orderFromSun: { $lt: 5 } }],
3});
{'name': 'Mars', 'orderFromSun': 4, ... }
{'name': 'Earth', 'orderFromSun': 3, ... }
crud_read.py
1cursor = coll.find(
2 {"$and": [{"orderFromSun": {"$gt": 2}}, {"orderFromSun": {"$lt": 5}}]}
3)
{'name': 'Mars', 'orderFromSun': 4, ... }
{'name': 'Earth', 'orderFromSun': 3, ... }

Se não utilizar o operador $and , o condutor encontra a mesma chave várias vezes no filtro de consulta e utiliza a última chave encontrada. Tente omitir o operador $and e veja o que acontece.

crud_read.py
1# find code goes here
2cursor = coll.find(
3 {"surfaceTemperatureC.mean": {"$lt": 15}, "surfaceTemperatureC.min": {"$gt": -100}}
4)
{'name': 'Earth', 'orderFromSun': 3, ...}

Observação

Implícito E

Especificar vários critérios é comum. Se você não especificar nenhum operador de query, o driver interpreta seus critérios de forma "E". No entanto, às vezes, você deve ser explícito ao especificar vários critérios, especialmente ao especificar critérios no mesmo campo.

Por exemplo, para localizar documentos na collection planets que tenham um valor de orderFromSun maior que 2 E menor que 5, você deve usar o operador de query $and .

crud-read.js
1const cursor = coll.find({
2 $and: [{ orderFromSun: { $gt: 2 } }, { orderFromSun: { $lt: 5 } }],
3});
{'name': 'Mars', 'orderFromSun': 4, ... }
{'name': 'Earth', 'orderFromSun': 3, ... }
crud_read.py
1cursor = coll.find(
2 {"$and": [{"orderFromSun": {"$gt": 2}}, {"orderFromSun": {"$lt": 5}}]}
3)
{'name': 'Mars', 'orderFromSun': 4, ... }
{'name': 'Earth', 'orderFromSun': 3, ... }

Se não utilizar o operador $and , o condutor encontra a mesma chave várias vezes no filtro de consulta e utiliza a última chave encontrada. Tente omitir o operador $and e veja o que acontece.

2

As queries OU são necessárias para especificar critérios mutuamente exclusivos. Por exemplo, você não pode corresponder a documentos na collection planets em que o valor orderFromSun é maior que 7 E menor que 2.

O exemplo a seguire mostra como usar o operador $or para expressar critérios mutuamente exclusivos.

CrudRead.cs
1// find code goes here
2var cursor = from planet in coll.AsQueryable()
3 where planet["orderFromSun"] > 7 || planet["orderFromSun"] < 2
4 select planet;
{ name: 'Mercury', orderFromSun: 1, ... }
{ name: 'Neptune', orderFromSun: 8, ... }
crudRead.go
1// find code goes here
2filter := bson.D{
3 {"$or",
4 bson.A{
5 bson.D{{"orderFromSun",
6 bson.D{{"$gt", 7}},
7 }},
8 bson.D{{"orderFromSun", bson.D{{"$lt", 2}}}},
9 },
10 },
11}
12
13cursor, err := coll.Find(context.TODO(), filter)
14if err != nil {
15 panic(err)
16}
map[name:Mercury orderFromSun:1 ...]
map[name:Neptune orderFromSun:8 ...]
CrudRead.java
1// find code goes here
2Bson filter = or(gt("orderFromSun", 7), lt("orderFromSun", 2));
3MongoCursor<Document> cursor = coll.find(filter).iterator();
{ name: 'Mercury', orderFromSun: 1, ... }
{ name: 'Neptune', orderFromSun: 8, ... }
crud-read.js
1// find code goes here
2const cursor = coll.find({
3 $or: [{ orderFromSun: { $gt: 7 } }, { orderFromSun: { $lt: 2 } }],
4});
{ name: 'Mercury', orderFromSun: 1, ... }
{ name: 'Neptune', orderFromSun: 8, ... }
crud_read.py
1# find code goes here
2cursor = coll.find(
3 {
4 "$or": [
5 {"orderFromSun": {"$gt": 7}},
6 {"orderFromSun": {"$lt": 2}},
7 ]
8 }
9)
{ name: 'Mercury', orderFromSun: 1, ... }
{ name: 'Neptune', orderFromSun: 8, ... }

Se você concluiu este guia com êxito, leu dados do MongoDB usando os operadores de query e as queries compostas do MongoDB.

Você pode combinar operadores de query de maneiras quase ilimitadas para expressar queries complexas. Por exemplo, pode consultar documentos que tenham anéis AND um composto químico específico em sua atmosfera, ou que tenham uma temperatura específica, AND todos tenham a letra 'E' no nome.

No próximo guia, você aprenderá como inserir dados no MongoDB.

Qual é o próximo
Inserir dados no MongoDB
15 minutos

Crie e insira documentos no MongoDB.

Guia de início
Capítulo 2
CRUD
  • Adicionar um Driver MongoDB
  • Ler dados no MongoDB
  • Ler dados do MongoDB com queries
  • Ler dados usando operadores e queries compostas
  • Inserir dados no MongoDB
  • Atualizar dados no MongoDB
  • Excluir dados do MongoDB