Operações compostas

Encontrar e atualizar

Para encontrar e atualizar um documento, use o método findOneAndUpdate() da classe MongoCollection.

val filter = equal("color", "green")
val update = set("food", "pizza")
val options = new FindOneAndUpdateOptions()
  .upsert(true)
  .maxTime(5, TimeUnit.SECONDS)
val observable: SingleObservable[Document] =
  collection.findOneAndUpdate(filter, update, options)
observable.subscribe(new Observer[Document] {
  override def onNext(doc: Document): Unit = println(doc.toJson())
  override def onError(e: Throwable): Unit = println(s"Failed: ${e.getMessage}")
  override def onComplete(): Unit = println("Completed")
})

{"_id": {"$oid": "1"}, "color": "green", "food": "pizza"}
Completed

Encontrar e substituir

Para encontrar e substituir um documento, use o método findOneAndReplace() da classe MongoCollection.

{"music": "classical", "color": "green"}

val replaceFilter = equal("color", "green")
val replacement = Document(
  "music" -> "classical",
  "color" -> "green"
)
val replaceOptions = new FindOneAndReplaceOptions()
  .returnDocument(ReturnDocument.AFTER)
val replaceObservable: SingleObservable[Document] =
  collection.findOneAndReplace(replaceFilter, replacement, replaceOptions)
replaceObservable.subscribe(new Observer[Document] {
  override def onNext(doc: Document): Unit = println(doc.toJson())
  override def onError(e: Throwable): Unit = println(s"Failed: ${e.getMessage}")
  override def onComplete(): Unit = println("Completed")
})

{"_id": {"$oid": "1"}, "music": "classical", "color": "green"}
Completed

Localize e exclua

Para encontrar e excluir um documento, use o método findOneAndDelete() da classe MongoCollection.

val deleteOptions = new FindOneAndDeleteOptions()
  .sort(descending("_id"))
val deleteObservable: SingleObservable[Document] =
  collection.findOneAndDelete(empty(), deleteOptions)
deleteObservable.subscribe(new Observer[Document] {
  override def onNext(doc: Document): Unit = println(doc.toJson())
  override def onError(e: Throwable): Unit = println(s"Failed: ${e.getMessage}")
  override def onComplete(): Unit = println("Completed")
})

{"_id": {"$oid": "2"}, "food": "pear", "color": "yellow"}
Completed

Exemplo com condição de corrida

O exemplo a seguir usa a função bookARoomUnsafe() para fazer o check-in de um hóspede em um quarto. A função executa as operações de localização e atualização separadamente.

def bookARoomUnsafe(guestName: String): Unit = {
  val availableFilter = equal("reserved", false)
  val findResults = Await.result(
    hotelCollection.find(availableFilter).first().toFuture(),
    Duration(10, TimeUnit.SECONDS)
  )
  if (Option(findResults).isEmpty) {
    println(s"Sorry, we are booked, $guestName")
    return
  }
  val room = findResults
  val roomName = room.getString("room")
  println(s"You got the $roomName, $guestName")
  val reserveUpdate = combine(
    set("reserved", true),
    set("guest", guestName)
  )
  val roomFilter = equal("_id", room.get("_id").get)
  Await.result(
    hotelCollection.updateOne(roomFilter, reserveUpdate).toFuture(),
    Duration(10, TimeUnit.SECONDS)
  )
}

Imagine que dois convidados, Jan e Pat, tentam reservar o mesmo quarto ao mesmo tempo.

Jane vê esta saída:

You got the Blue Room, Jan

Pat vê esta saída:

You got the Blue Room, Pat

Ao examinar o banco de dados, você verá o seguinte documento:

{"_id": {"$oid": "1"}, "guest": "Jan", "room": "Blue Room", "reserved": true}

Seu aplicativo informou a Pat e Jan que eles haviam reservado a sala, mas o banco de dados mostra uma reserva apenas para Jan. Aqui está a sequência de operações que o MongoDB executou:

1. Encontre e devolva o quarto vazio para Jan

2. Encontre e devolva o quarto vazio para Pat

3. Atualize a sala com a reserva de Pat

4. Atualize o quarto com a reserva de Jan

Embora Pat tenha reservado o quarto por um momento, a operação de atualização de Jan sobrescreveu a reserva de Pat porque foi a última a ser executada.

Exemplo sem condição de corrida

O exemplo a seguir usa a função bookARoomSafe() para fazer o check-in de um hóspede em um quarto. A função usa findOneAndUpdate() para executar as operações de localização e atualização como uma única operação atômica.

def bookARoomSafe(guestName: String): Unit = {
  val reserveUpdate = combine(
    set("reserved", true),
    set("guest", guestName)
  )
  val availableFilter = equal("reserved", false)
  val room: Document = Await.result(
    hotelCollection.findOneAndUpdate(availableFilter, reserveUpdate).toFuture(),
    Duration(10, TimeUnit.SECONDS)
  )
  if (Option(room).isEmpty) {
    println(s"Sorry, we are booked, $guestName")
    return
  }
  val roomName = room.getString("room")
  println(s"You got the $roomName, $guestName")
}

Imagine que dois convidados, Jan e Pat, tentam reservar o mesmo quarto ao mesmo tempo.

Jane vê esta saída:

You got the Blue Room, Jan

Pat vê esta saída:

Sorry, we are booked, Pat

Ao examinar o banco de dados, você verá o seguinte documento:

{"_id": {"$oid": "1"}, "guest": "Jan", "room": "Blue Room", "reserved": true}

Jan reservou a sala e Pat recebeu a mensagem correta de que não há salas disponíveis. Aqui está a sequência de operações que o MongoDB executou:

1. Encontre um quarto vazio para Jan e reserve-o

2. Tente encontrar e reservar uma sala vazia para Pat

3. Não encontre salas vazias e conclua sem emitir um valor

Como findOneAndUpdate() executa a pesquisa e atualiza atomicamente, a operação de Pat não pode ler a sala como disponível após a conclusão da reserva de Jan.

Para obter mais informações sobre os métodos e as classes usados nesta seção, consulte a seguinte documentação da API:

• MongoCollection

• Filtros

• Updates

• Tipos