Ler dados usando operadores e queries compostas
Visão geral
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
O que você precisa
Uma connection string para sua deployment do MongoDB.
Exemplos de conjuntos de dados carregados em seu cluster.
Procedimento
Ler dados com campos incorporados e operadores de comparação
Neste exercício, você lerá dados usando operadores de comparação.
Conecte-se à sua instância do MongoDB.
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.
1 using MongoDB.Bson;
2 using MongoDB.Driver;
3
4 // Replace the uri string with your MongoDB deployment's connection string.
5 var uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
6
7 var client = new MongoClient(uri);
8
9 var coll = client.GetDatabase("sample_guides").GetCollection<BsonDocument>("planets");
10 // find code goes here
11 var cursor = coll.AsQueryable();
12
13 foreach (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 .
1 package main 2 3 import ( 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 12 func 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 .
1 import com.mongodb.client.*; 2 import com.mongodb.client.model.Filters.*; 3 import org.bson.Document; 4 import org.bson.conversions.Bson; 5 6 public 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.
1 const { MongoClient } = require("mongodb"); 2 // Replace the uri string with your MongoDB deployment's connection string. 3 const uri = 4 "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"; 5 const client = new MongoClient(uri); 6 async 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 } 20 run().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.
1 from pymongo import MongoClient 2 3 # Replace the uri string with your MongoDB deployment's connection string. 4 uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority" 5 6 client = MongoClient(uri) 7 coll = client.sample_guides.planets 8 9 # find code goes here 10 cursor = coll.find() 11 12 for doc in cursor: 13 print(doc) 14 15 # Close the connection to MongoDB when you're done. 16 client.close()
Dica
MongoDB+srv
Certifique-se de ter instalado o PyMongo com a opção srv
.
python3 -m pip install "pymongo[srv]"
Selecione documentos usando o operador "menor de".
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).
// find code goes here
var cursor = from planet in coll.AsQueryable()
where planet["surfaceTemperatureC.mean"] < 15
select planet;
1 // find code goes here 2 filter := bson.D{{"surfaceTemperatureC.mean", bson.D{{"$lt", 15}}}} 3 cursor, err := coll.Find(context.TODO(), filter) 4 if 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.
1 // find code goes here 2 Bson filter = lt("surfaceTemperatureC.mean", 15); 3 MongoCursor<Document> cursor = coll.find(filter).iterator();
// find code goes here const cursor = coll.find({ "surfaceTemperatureC.mean": { $lt: 15 } });
# find code goes here cursor = coll.find({"surfaceTemperatureC.mean": {"$lt": 15}})
Verifique seus resultados.
Veja o código completo, seguido pela amostra de saída. Os resultados foram truncados para fins de exibição.
1 using MongoDB.Bson;
2 using MongoDB.Driver;
3
4 // Replace the uri string with your MongoDB deployment's connection string.
5 var uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
6
7 var client = new MongoClient(uri);
8
9 var coll = client.GetDatabase("sample_guides").GetCollection<BsonDocument>("planets");
10 // find code goes here
11 var cursor = from planet in coll.AsQueryable()
12 where planet["surfaceTemperatureC.mean"] < 15
13 select planet;
14
15 foreach (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 }, ... }
1 package main 2 3 import ( 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 12 func 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>] ... ]
1 import com.mongodb.client.*; 2 import com.mongodb.client.model.Filters.*; 3 import org.bson.Document; 4 import org.bson.conversions.Bson; 5 6 public 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 }, ... }
1 const { MongoClient } = require("mongodb"); 2 // Replace the uri string with your MongoDB deployment's connection string. 3 const uri = 4 "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"; 5 const client = new MongoClient(uri); 6 async 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 } 20 run().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 }, ... }
1 from pymongo import MongoClient 2 3 # Replace the uri string with your MongoDB deployment's connection string. 4 uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority" 5 6 client = MongoClient(uri) 7 coll = client.sample_guides.planets 8 9 # find code goes here 10 cursor = coll.find({"surfaceTemperatureC.mean": {"$lt": 15}}) 11 12 for doc in cursor: 13 print(doc) 14 15 # Close the connection to MongoDB when you're done. 16 client.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 }, ... }
Leia dados com queries compostas
Agora você lerá dados do MongoDB usando uma lógica E e OU para formar queries compostas.
Escreva uma query AND.
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
.
1 // find code goes here
2 var cursor = from planet in coll.AsQueryable()
3 where planet["surfaceTemperatureC.mean"] < 15 && planet["surfaceTemperatureC.min"] > -100
4 select planet;
5
{'name': 'Earth', 'orderFromSun': 3, ...}
1 // find code goes here 2 filter := 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 } 14 cursor, err := coll.Find(context.TODO(), filter) 15 if err != nil { 16 panic(err) 17 }
map[name:Earth orderFromSun:3 ...]
1 // find code goes here 2 Bson filter = and(lt("surfaceTemperatureC.mean", 15), gt("surfaceTemperatureC.min", -100)); 3 MongoCursor<Document> cursor = coll.find(filter).iterator();
{'name': 'Earth', 'orderFromSun': 3, ...}
1 // find code goes here 2 const 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
.
1 const cursor = coll.find({ 2 $and: [{ orderFromSun: { $gt: 2 } }, { orderFromSun: { $lt: 5 } }], 3 });
{'name': 'Mars', 'orderFromSun': 4, ... } {'name': 'Earth', 'orderFromSun': 3, ... }
1 cursor = 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.
1 # find code goes here 2 cursor = 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
.
1 const cursor = coll.find({ 2 $and: [{ orderFromSun: { $gt: 2 } }, { orderFromSun: { $lt: 5 } }], 3 });
{'name': 'Mars', 'orderFromSun': 4, ... } {'name': 'Earth', 'orderFromSun': 3, ... }
1 cursor = 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.
Escreva uma query OR.
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.
1 // find code goes here
2 var 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, ... }
1 // find code goes here 2 filter := 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 13 cursor, err := coll.Find(context.TODO(), filter) 14 if err != nil { 15 panic(err) 16 }
map[name:Mercury orderFromSun:1 ...] map[name:Neptune orderFromSun:8 ...]
1 // find code goes here 2 Bson filter = or(gt("orderFromSun", 7), lt("orderFromSun", 2)); 3 MongoCursor<Document> cursor = coll.find(filter).iterator();
{ name: 'Mercury', orderFromSun: 1, ... } { name: 'Neptune', orderFromSun: 8, ... }
1 // find code goes here 2 const cursor = coll.find({ 3 $or: [{ orderFromSun: { $gt: 7 } }, { orderFromSun: { $lt: 2 } }], 4 });
{ name: 'Mercury', orderFromSun: 1, ... } { name: 'Neptune', orderFromSun: 8, ... }
1 # find code goes here 2 cursor = coll.find( 3 { 4 "$or": [ 5 {"orderFromSun": {"$gt": 7}}, 6 {"orderFromSun": {"$lt": 2}}, 7 ] 8 } 9 )
{ name: 'Mercury', orderFromSun: 1, ... } { name: 'Neptune', orderFromSun: 8, ... }
Resumo
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.
Veja também
O driver MongoDB C# documentação
A documentação do driver Go do MongoDB
A documentação do driver MongoDB Java(Sync)
Documentação do driver Node.js do MongoDB
O PyMongo documentação
Crie e insira documentos no MongoDB.