Menu Docs
Página inicial do Docs
/
Idiomas
/
Scala
/
Scala
/
Tutorials

Operações de Escrita

Nesta página

  • Pré-requisitos
  • Conecte-se a um MongoDB deployment
  • Insira um documento
  • Insira vários documentos
  • Atualizar documentos existentes
  • Filtros
  • Operadores de atualização
  • Atualizar um único documento
  • Atualizar vários documentos
  • UpdateOptions
  • Substituir um documento existente
  • Filtros
  • Substituir um documento
  • UpdateOptions
  • Exclua documentos
  • Filtros
  • Excluir um único documento
  • Excluir vários documentos
  • Escreva preocupação

Você pode executar operações de gravação para inserir novos documentos, atualizar documentos existentes, substituir um documento existente ou excluir documentos existentes de uma coleção.

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 na documentação de ativos do Github.

  • As seguintes declarações de importação:

import org.mongodb.scala._
import org.mongodb.scala.model._
import org.mongodb.scala.model.Filters._
import org.mongodb.scala.model.Updates._
import org.mongodb.scala.model.UpdateOptions
import org.mongodb.scala.bson.BsonObjectId

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 .

Insira um documento

Para inserir um único documento na coleção, você pode usar o método insertOne() da coleção:

val document = Document("name" -> "Café Con Leche" ,
                        "contact" -> Document("phone" -> "228-555-0149",
                                              "email" -> "cafeconleche@example.com",
                                              "location" -> Seq(-73.92502, 40.8279556)),
                        "stars" -> 3, "categories" -> Seq("Bakery", "Coffee", "Pastries"))
collection.insertOne(document).printResults()

Observação

Se nenhum campo _id de nível superior for especificado no documento, o MongoDB gerará automaticamente um valor e adicionará esse campo ao documento inserido.

Insira vários documentos

Para inserir vários documentos, você pode usar o método insertMany() da collection, que recebe uma lista de documentos a serem inseridos como parâmetro.

O exemplo a seguir insere dois documentos na coleção:

val doc1 = Document("name" -> "Amarcord Pizzeria" ,
                    "contact" -> Document("phone" -> "264-555-0193",
                                          "email" -> "amarcord.pizzeria@example.net",
                                          "location" -> Seq(-73.88502, 40.749556)),
                    "stars" -> 2, "categories" -> Seq("Pizzeria", "Italian", "Pasta"))
val doc2 = Document("name" -> "Blue Coffee Bar" ,
                    "contact" -> Document("phone" -> "604-555-0102",
                                          "email" -> "bluecoffeebar@example.com",
                                          "location" -> Seq(-73.97902, 40.8479556)),
                    "stars" -> 5, "categories" -> Seq("Coffee", "Pastries"))
collection.insertMany(Seq(doc1, doc2)).printResults()

Observação

Se nenhum campo _id de nível superior for especificado no documento, o MongoDB gerará automaticamente um valor e adicionará esse campo ao documento inserido.

Atualizar documentos existentes

Para atualizar documentos existentes em uma collection, você pode usar os métodos updateOne() ou updateMany() da collection.

Filtros

Você pode passar um documento de filtro para os métodos para especificar quais documentos atualizar. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

Operadores de atualização

Para alterar um campo em um documento, o MongoDB fornece operadores de atualização. Para especificar a modificação a ser executada usando os operadores de atualização, crie um documento de atualização. Para saber mais sobre operadores de atualização, consulte Operadores de atualização no manual do servidor MongoDB.

Para facilitar a criação de documentos de atualização, o driver fornece a classe auxiliar Updates . Para saber mais sobre como usar construtores para especificar atualizações, consulte o guia Atualizações .

Importante

O campo _id é imutável, então você não pode alterar o valor do campo _id em um documento.

Atualizar um único documento

O método updateOne() atualiza um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

A operação a seguir na collection restaurants atualiza um documento no qual o valor do campo _id é BsonObjectId("57506d62f57802807471dd41"):

collection.updateOne(
                equal("_id", BsonObjectId("57506d62f57802807471dd41")),
                combine(set("stars", 1), set("contact.phone", "228-555-9999"), currentDate("lastModified")))
          .printResults()

Especificamente, a operação utiliza os seguintes métodos:

  • Updates.set() para definir o valor do campo stars como 1 e do campo contact.phone como "228-555-9999"

  • Updates.currentDate() para modificar o campo lastModified para a data atual. Se o campo lastModified não existir, o operador adicionará o campo ao documento.

Atualizar vários documentos

O método updateMany() atualiza todos os documentos que correspondem à condição do filtro.

A seguinte operação na collection restaurants atualiza todos os documentos nos quais o valor do campo stars é 2:

collection.updateMany(
              equal("stars", 2),
              combine(set("stars", 0), currentDate("lastModified")))
          .println()

Especificamente, a operação utiliza os seguintes métodos:

  • Updates.set() para definir o valor do campo stars como 0

  • Updates.currentDate() para definir o campo lastModified para a data atual. Se o campo lastModified não existir, o operador adicionará o campo ao documento.

UpdateOptions

Ao usar os métodos updateOne() e updateMany() , você pode incluir um documento UpdateOptions para especificar a opção upsert ou a opção bypassDocumentationValidation :

collection.updateOne(
                equal("_id", 1),
                combine(set("name", "Fresh Breads and Tulips"), currentDate("lastModified")),
                UpdateOptions().upsert(true).bypassDocumentValidation(true))
          .printResults()

Substituir um documento existente

Para substituir um documento existente em uma coleção, você pode usar o método replaceOne() da coleção.

Importante

O campo _id é imutável, então você não pode substituir o campo _id em um documento.

Filtros

Você pode passar um documento de filtro para o método replaceOne() para especificar qual documento substituir. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

O método replaceOne() substitui, no máximo, um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

Substituir um documento

Para substituir um documento, passe um novo documento para o método replaceOne() .

Importante

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , não poderá especificar um valor diferente para o campo _id .

A seguinte operação na coleção restaurants substitui o documento no qual o valor do campo _id é BsonObjectId("57506d62f57802807471dd41"):

collection.replaceOne(
                equal("_id", BsonObjectId("57506d62f57802807471dd41")),
                Document("name" -> "Green Salads Buffet", "contact" -> "TBD",
                         "categories" -> Seq("Salads", "Health Foods", "Buffet")))
         .printResults()

UpdateOptions

Ao usar o método replaceOne() , você pode incluir um documento UpdateOptions para especificar a opção upsert ou a opção bypassDocumentationValidation :

collection.replaceOne(
                equal("name", "Orange Patisserie and Gelateria"),
                Document("stars" -> 5, "contact"  -> "TBD",
                         "categories" -> Seq("Cafe", "Pastries", "Ice Cream")),
                UpdateOptions().upsert(true).bypassDocumentValidation(true))
          .printResults()

Exclua documentos

Para excluir documentos em uma coleção, você pode usar os métodos deleteOne() e deleteMany() .

Filtros

Você pode passar um documento de filtro para os métodos para especificar quais documentos excluir. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

Excluir um único documento

O método deleteOne() exclui no máximo um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

A seguinte operação na collection restaurants exclui um documento no qual o valor do campo _id é ObjectId("57506d62f57802807471dd41"):

collection.deleteOne(equal("_id", new ObjectId("57506d62f57802807471dd41"))).subscribe(new ObservableSubscriber<DeleteResult>())

Excluir vários documentos

O método deleteMany() exclui todos os documentos que correspondem à condição do filtro.

A operação a seguir na collection restaurants exclui todos os documentos nos quais o valor do campo stars é 4:

collection.deleteMany(equal("stars", 4)).printResults()

Escreva preocupação

Preocupação de gravação descreve o nível de confirmação solicitado do MongoDB para operações de gravação.

É possível configurar uma write concern nos seguintes níveis:

  • Em um MongoClient das seguintes maneiras:

    • Ao criar uma instância do MongoClientSettings :

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

    • Ao criar uma instância do ConnectionString :

      val mongoClientt = MongoClient("mongodb://host1:27017,host2:27017/?w=majority")

  • Em um MongoDatabase usando o método withWriteConcern() :

    val database = mongoClient.getDatabase("test").withWriteConcern(WriteConcern.MAJORITY)

  • Em um MongoCollection usando o método withWriteConcern() :

    val collection = database.getCollection("restaurants").withWriteConcern(WriteConcern.MAJORITY)

MongoDatabase e MongoCollection instâncias são imutáveis. Chamar withWriteConcern() 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 collWithWriteConcern tem a write concern de majority , enquanto a read preference do collection não é afetada:

val collWithWriteConcern = collection.withWriteConcern(WriteConcern.MAJORITY)

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

Criptografia em execução

Próximo

Operações de gravação em massa