UpdateBuilder

abstract def bulkRecover: Option[(Exception) ⇒ Future[GenericCollection.UpdateWriteResult]]

abstract def bypassDocumentValidation: Boolean

the flag to bypass document validation during the operation

abstract def maxBulkSize(max: Int): GenericCollection.UpdateBuilder

Returns an update builder with the given maxBulkSize.

abstract def maxBulkSize: Int

the maximum number of document(s) per bulk

abstract def ordered: Boolean

the ordered behaviour

abstract def writeConcern: WriteConcern

the writer concern to be used

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (GenericCollection.UpdateBuilder, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def element[Q, U](q: Q, u: U, upsert: Boolean, multi: Boolean, collation: Option[Collation], arrayFilters: Seq[P.Document])(implicit qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateElement]

Prepares an UpdateElement

final def element[Q, U](q: Q, u: U, upsert: Boolean, multi: Boolean, collation: Option[Collation])(implicit qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateElement]

Prepares an UpdateElement

final def element[Q, U](q: Q, u: U, upsert: Boolean = false, multi: Boolean = false)(implicit qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateElement]

Prepares an UpdateElement

def ensuring(cond: (GenericCollection.UpdateBuilder) ⇒ Boolean, msg: ⇒ Any): GenericCollection.UpdateBuilder

def ensuring(cond: (GenericCollection.UpdateBuilder) ⇒ Boolean): GenericCollection.UpdateBuilder

def ensuring(cond: Boolean, msg: ⇒ Any): GenericCollection.UpdateBuilder

def ensuring(cond: Boolean): GenericCollection.UpdateBuilder

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def many(updates: Iterable[GenericCollection.UpdateElement])(implicit ec: ExecutionContext): Future[GenericCollection.MultiBulkWriteResult]

Updates many documents, according the ordered behaviour.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def updateMany(
  coll: BSONCollection,
  docs: Iterable[BSONDocument])(implicit ec: ExecutionContext) = {
  val update = coll.update(ordered = true)
  val elements = Future.sequence(docs.map { doc =>
    update.element(
      q = BSONDocument("update" -> "selector"),
      u = BSONDocument(f"$$set" -> doc),
      upsert = true,
      multi = false)
  })

  elements.flatMap { ups =>
    update.many(ups) // Future[MultiBulkWriteResult]
  }
}

final def many(firstUpdate: GenericCollection.UpdateElement, updates: Iterable[GenericCollection.UpdateElement])(implicit ec: ExecutionContext): Future[GenericCollection.MultiBulkWriteResult]

Updates many documents, according the ordered behaviour.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def updateMany(
  coll: BSONCollection,
  first: BSONDocument,
  docs: Iterable[BSONDocument])(implicit ec: ExecutionContext) = {
  val update = coll.update(ordered = true)
  val elements = Future.sequence(docs.map { doc =>
    update.element(
      q = BSONDocument("update" -> "selector"),
      u = BSONDocument(f"$$set" -> doc),
      upsert = true,
      multi = false)
  })

  for {
    _ <- update.element(
      q = BSONDocument("update" -> "selector"),
      u = BSONDocument(f"$$set" -> first),
      upsert = true,
      multi = false)
    ups <- elements
    res <- update.many(ups) // Future[MultiBulkWriteResult]
  } yield res
}

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def one[Q, U](q: Q, u: U, upsert: Boolean, multi: Boolean, collation: Option[Collation], arrayFilters: Seq[P.Document])(implicit ec: ExecutionContext, qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateWriteResult]

Performs a single update (see UpdateElement).

final def one[Q, U](q: Q, u: U, upsert: Boolean, multi: Boolean, collation: Option[Collation])(implicit ec: ExecutionContext, qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateWriteResult]

Performs a single update (see UpdateElement).

final def one[Q, U](q: Q, u: U, upsert: Boolean = false, multi: Boolean = false)(implicit ec: ExecutionContext, qw: P.Writer[Q], uw: P.Writer[U]): Future[GenericCollection.UpdateWriteResult]

Performs a single update (see UpdateElement).

import scala.concurrent.ExecutionContext.Implicits.global

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def updateOne(coll: BSONCollection, q: BSONDocument, u: BSONDocument) =
  coll.update.one(q, u, upsert = true)

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def →[B](y: B): (GenericCollection.UpdateBuilder, B)