Escribe datos en MongoDB

Overview

En esta página, puede ver ejemplos de código copiables que muestran métodos comunes que puede usar para escribir datos en MongoDB utilizando el controlador Scala.

Tip

Para obtener más información sobre cualquiera de los métodos que se muestran en esta página, consulte el enlace proporcionado en cada sección.

Para utilizar un ejemplo de esta página, copie el ejemplo de código en el Aplicación de ejemplo o su propia aplicación. Asegúrese de reemplazar todos los marcadores de posición en los ejemplos de código, como <connection string URI>, con los valores relevantes para su implementación de MongoDB.

Aplicación de muestra

Puede utilizar la siguiente aplicación de muestra para probar los ejemplos de código en esta página. Para usar la aplicación de muestra, siga los siguientes pasos:

Asegúrese de tener el controlador Scala instalado en su proyecto Maven o sbt.
Copia el siguiente código y pégalo en un nuevo archivo .scala.
Copia un ejemplo de código de esta página y pégalo en las líneas especificadas del archivo.

1 import org.mongodb.scala._
2 import org.mongodb.scala.bson.Document
3 import org.mongodb.scala.model._
4 import org.mongodb.scala.model.Filters._
5 import org.mongodb.scala.result._
6 import org.mongodb.scala.model.Updates._
7 
8 object SampleWriteApp {
9 
10   def main(args: Array[String]): Unit = {
11     val mongoClient = MongoClient("<connection string URI>")
12     val database: MongoDatabase = mongoClient.getDatabase("<database name>")
13     val collection: MongoCollection[Document] = database.getCollection("<collection name>")
14 
15     // Start example code here
16 
17     // End example code here
18 
19     // Wait for the operations to complete before closing client
20     // Note: This example uses Thread.sleep() for brevity and does not guarantee all
21     // operations will be completed in time
22     Thread.sleep(1000)
23     mongoClient.close()
24   }
25 }

Inserte uno

El siguiente código muestra cómo insertar un solo documento en una colección:

val doc: Document = Document("<field name>" -> "<value>")
val observable: Observable[InsertOneResult] = collection.insertOne(doc)
observable.subscribe(new Observer[InsertOneResult] {
  override def onNext(result: InsertOneResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método insertOne(), consulte la Guía deinserción de documentos.

Insertar múltiples

El siguiente código muestra cómo insertar varios documentos en una colección:

val docs: Seq[Document] = Seq(
  Document("<field name>" -> "<value>"),
  Document("<field name>" -> "<value>")
)
val observable: Observable[InsertManyResult] = collection.insertMany(docs)
observable.subscribe(new Observer[InsertManyResult] {
  override def onNext(result: InsertManyResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método insertMany(), consultar la guía Insertar Documentos.

Actualiza uno

El siguiente código muestra cómo actualizar un solo documento en una colección creando o editando un campo:

val filter = equal("<field to match>", "<value to match>")
val update = set("<field name>", "<value>")
val observable: Observable[UpdateResult] = collection.updateOne(filter, update)
observable.subscribe(new Observer[UpdateResult] {
  override def onNext(result: UpdateResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método updateOne(), consulte la Guía para actualizar documentos.

Actualiza múltiples

El siguiente código muestra cómo actualizar varios documentos en una colección creando o editando un campo:

val filter = equal("<field to match>", "value to match")
val update = set("<field name>", "<value>")
val observable: Observable[UpdateResult] = collection.updateMany(filter, update)
observable.subscribe(new Observer[UpdateResult] {
  override def onNext(result: UpdateResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método updateMany(), consulte la Guía para actualizar documentos.

Reemplace uno

El siguiente código muestra cómo reemplazar un solo documento en una colección con un nuevo documento:

val filter = equal("<field to match>", "<value to match>")
val replacementDoc: Document = Document("<field name>" -> "<value>")
val observable: Observable[UpdateResult] = collection.replaceOne(filter, replacementDoc)
observable.subscribe(new Observer[UpdateResult] {
  override def onNext(result: UpdateResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para aprender más sobre el método replaceOne(), consulta la guía Reemplazar Documentos.

deleteOne

El siguiente código muestra cómo eliminar un solo documento en una colección:

val filter = equal("<field to match>", "<value to match>")
val observable: Observable[DeleteResult] = collection.deleteOne(filter)
observable.subscribe(new Observer[DeleteResult] {
  override def onNext(result: DeleteResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método deleteOne(), consulta la guía Borrar Documentos.

Borrar múltiples

El siguiente código muestra cómo eliminar varios documentos en una colección:

val filter = equal("<field to match>", "<value to match>")
val observable: Observable[DeleteResult] = collection.deleteMany(filter)
observable.subscribe(new Observer[DeleteResult] {
  override def onNext(result: DeleteResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el método deleteMany(), consulta la guía Borrar Documentos.

Guardado masivo

El siguiente código muestra cómo realizar múltiples operaciones de guardar en una sola operación masiva:

val operations = Seq(
  InsertOneModel(Document("<field name>" -> "<value>")),
  UpdateManyModel(equal("<field to match>", "<value to match>"), set("<field name>", "<value>")),
  DeleteOneModel(equal("<field to match>", "<value to match>"))
)
val observable: Observable[BulkWriteResult] = collection.bulkWrite(operations)
observable.subscribe(new Observer[BulkWriteResult] {
  override def onNext(result: BulkWriteResult): Unit = println(result)
  override def onError(e: Throwable): Unit = println("Failed: " + e.getMessage)
  override def onComplete(): Unit = println("Completed")
})

Para obtener más información sobre el bulkWrite() método, consulte la guía Operaciones de escritura masiva.

Volver

Monitorear cambios

Insert

1	import org.mongodb.scala._
2	import org.mongodb.scala.bson.Document
3	import org.mongodb.scala.model._
4	import org.mongodb.scala.model.Filters._
5	import org.mongodb.scala.result._
6	import org.mongodb.scala.model.Updates._
7
8	object SampleWriteApp {
9
10	def main(args: Array[String]): Unit = {
11	val mongoClient = MongoClient("<connection string URI>")
12	val database: MongoDatabase = mongoClient.getDatabase("<database name>")
13	val collection: MongoCollection[Document] = database.getCollection("<collection name>")
14
15	// Start example code here
16
17	// End example code here
18
19	// Wait for the operations to complete before closing client
20	// Note: This example uses Thread.sleep() for brevity and does not guarantee all
21	// operations will be completed in time
22	Thread.sleep(1000)
23	mongoClient.close()
24	}
25	}