Ler operações

Nesta página

Pré-requisitos

Conecte-se a um MongoDB deployment
Consultar uma Collection
Filtros de query
Filtro vazio
Auxiliar de filtros
FindObservable
Projeções
Tipos
Classificar com projeções
explicar
readPreference
Preocupação de leitura

As operações de leitura recuperam documentos ou informações sobre documentos de uma collection. Você pode especificar um filtro para recuperar somente os documentos que correspondam à condição do filtro.

Pré-requisitos

Você deve configurar os seguintes componentes para executar os exemplos de código neste guia:

Uma test.restaurants coleção preenchida com documentos do restaurants.json arquivo nos ativos de documentação do Github.
As seguintes declarações de importação:

import org.mongodb.scala._
import org.mongodb.scala.model.Filters._
import org.mongodb.scala.model.Projections._
import org.mongodb.scala.model.Sorts._

Observação

Este guia usa as implicações do Observable como abordadas no Quick Start Primary.

Conecte-se a um MongoDB deployment

Primeiro, conecte a um MongoDB deployment e, em seguida, declare e defina as instâncias MongoDatabase e MongoCollection .

O código a seguir se conecta a uma MongoDB deployment standalone em execução em localhost na porta 27017. Em seguida, define a variável database para fazer referência ao banco de dados test e a variável collection para fazer referência à coleção restaurants :

val mongoClient: MongoClient = MongoClient()
val database: MongoDatabase = mongoClient.getDatabase("test")
val collection: MongoCollection[Document] = database.getCollection("restaurants")

Para saber mais sobre como se conectar a sistemas do MongoDB, consulte o tutorial Conectar ao MongoDB .

Consultar uma Collection

Para fazer query da coleção, você pode usar o método find() da coleção.

Você pode chamar o método sem argumentos para consultar todos os documentos em uma coleção:

collection.find().printResults()

Ou você pode passar um filtro para fazer query de documentos que correspondam aos critérios do filtro:

collection.find(equal("name", "456 Cookies Shop"))
          .printResults()

Filtros de query

Para consultar documentos que correspondam a determinadas condições, passe um documento de filtro para o método find() .

Filtro vazio

Para especificar um filtro vazio e corresponder a todos os documentos em uma collection, use um objeto Document vazio:

collection.find(Document()).printResults()

Dica

Ao usar o método find() , você também pode chamar o método sem passar nenhum objeto de filtro para corresponder a todos os documentos em uma collection.

collection.find().printResults()

Auxiliar de filtros

Para facilitar a criação de documentos de filtro, o driver fornece a classe Filters que fornece métodos auxiliares de condição de filtro. Para saber mais sobre esses métodos, consulte o guia Filtros .

Esse exemplo de operação de localização inclui uma instância de filtro Document que especifica as seguintes condições:

stars o valor do campo é maior ou igual a 2 e menor que 5
categories campo é igual a "Bakery", ou se categories for um campo de array, contém a string "Bakery" como um elemento

collection.find(
     Document("stars" -> Document("$gte" -> 2, "$lt"-> 5, "categories" -> "Bakery")))
    .printResults()

O exemplo a seguir especifica a mesma condição de filtro usando os métodos auxiliares Filters :

collection.find(and(gte("stars", 2), lt("stars", 5), equal("categories", "Bakery")))
          .printResults()

Para visualizar uma lista de operadores de filtro de query, consulte Operadores de query e projeção no manual do servidor MongoDB. Para ver uma lista de Filters auxiliares do , consulte a documentação da API de filtros.

FindObservable

O método find() retorna uma instância da classe FindObservable . A classe fornece vários métodos que você pode conectar ao método find() para modificar a saída ou o comportamento da query, como sort() ou projection(), bem como para iterar os resultados por meio do método subscribe() .

Projeções

Por padrão, as queries no MongoDB retornam todos os campos em documentos correspondentes. Para especificar os campos a serem retornados nos documentos correspondentes, você pode especificar um documento de projeção.

Este exemplo de operação de busca inclui uma projeção Document que especifica que os documentos correspondentes incluem somente os campos name, stars e categories :

collection.find(and(gte("stars", 2), lt("stars", 5), equal("categories", "Bakery")))
          .projection(Document("name" -> 1, "stars" -> 1, "categories" -> 1, "_id" -> 0))
          .printResults()

Para facilitar a criação de documentos de projeção , o driver fornece os métodos de assistente de classe Projections . Para saber mais sobre esses métodos, consulte o guia Projeções .

collection.find(and(gte("stars", 2), lt("stars", 5), equal("categories", "Bakery")))
          .projection(fields(include("name", "stars", "categories"), excludeId()))
          .printResults()

No documento de projeção, você também pode especificar uma expressão de projeção usando um operador de projeção.

Para visualizar um exemplo que utiliza o método Projections.metaTextScore(), consulte o tutorial Atlas Searchde Texto .

Tipos

Para classificar documentos, passe um documento de especificação de classificação para o método FindObservable.sort() . O driver fornece métodos assistente Sorts para facilitar a criação do documento de especificação de classificação. Para saber como criar critérios de classificação usando construtores, consulte o guia Classificações .

collection.find(and(gte("stars", 2), lt("stars", 5), equal("categories", "Bakery")))
          .sort(ascending("name"))
          .printResults()

Classificar com projeções

Os métodos FindObservable em si retornam objetos FindObservable e, como tal, você pode anexar vários métodos FindObservable ao método find() :

collection.find(and(gte("stars", 2), lt("stars", 5), eq("categories", "Bakery")))
          .explain()
          .printResults()

explicar

Para explicar uma operação de localização, chame o método FindObservable.explain() :

collection.find(and(gte("stars", 2), lt("stars", 5), eq("categories", "Bakery")))
          .explain()
          .printResults()

readPreference

Para operações de leitura em conjuntos de réplicas ou clusters fragmentados, você pode configurar a preferência de leitura nos seguintes níveis:

Em um MongoClient das seguintes maneiras:
- Ao criar uma instância do MongoClientSettings :
  val mongoClient = MongoClient(MongoClientSettings.builder() .applyConnectionString(ConnectionString("mongodb://host1,host2")) .readPreference(ReadPreference.secondary()) .build())
- Ao criar uma instância do ConnectionString :
  val mongoClient = MongoClient("mongodb://host1:27017,host2:27017/?readPreference=secondary")
Em um MongoDatabase usando o método withReadPreference() :
```
val database = mongoClient.getDatabase("test")
                          .withReadPreference(ReadPreference.secondary())
```
Em um MongoCollection usando o método withReadPreference() :
```
val collection = database.getCollection("restaurants")
                         .withReadPreference(ReadPreference.secondary())
```

MongoDatabase e MongoCollection instâncias são imutáveis. Chamar withReadPreference() em uma instância MongoDatabase ou MongoCollection existente retorna uma nova instância e não afeta a instância na qual o método é chamado.

No exemplo a seguir, a instância collectionWithReadPref tem a preferência de leitura de primaryPreferred , enquanto a preferência de leitura do collection não é afetada:

val collectionWithReadPref = collection.withReadPreference(ReadPreference.primaryPreferred())

Preocupação de leitura

Para operações de leitura em conjuntos de réplicas ou clusters fragmentados, os aplicativos podem configurar a read concern nos seguintes níveis:

Em um MongoClient das seguintes maneiras:

Ao criar uma instância do MongoClientSettings :

val mongoClient = MongoClient(MongoClientSettings.builder()
                          .applyConnectionString(ConnectionString("mongodb://host1,host2"))
                          .readConcern(ReadConcern.MAJORITY)
                          .build())

Ao criar uma instância do ConnectionString :
```
val mongoClient = MongoClient("mongodb://host1:27017,host2:27017/?readConcernLevel=majority")
```

Em um MongoDatabase usando o método withReadConcern() :
```
val database = mongoClient.getDatabase("test")
                          .withReadConcern(ReadConcern.MAJORITY)
```
Em um MongoCollection usando o método withReadConcern() :
```
val collection = database.getCollection("restaurants")
                         .withReadConcern(ReadConcern.MAJORITY)
```

MongoDatabase e MongoCollection instâncias são imutáveis. Chamar withReadConcern() em uma instância MongoDatabase ou MongoCollection existente retorna uma nova instância e não afeta a instância na qual o método é chamado.

No exemplo a seguir, a instância collWithReadConcern tem um read concern AVAILABLE , enquanto a read concern do collection não é afetada:

val collWithReadConcern = collection.withReadConcern(ReadConcern.AVAILABLE)

Você pode construir instâncias do MongoClientSettings, MongoDatabase ou MongoCollection para incluir combinações de read concerns, read preferences e write concerns.

Por exemplo, o seguinte código define todos os três no nível da collection:

val collection = database.getCollection("restaurants")
                         .withReadPreference(ReadPreference.primary())
                         .withReadConcern(ReadConcern.MAJORITY)
                         .withWriteConcern(WriteConcern.MAJORITY)

Voltar

Crie índices

Criptografia em execução