UpdateBuilder

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

abstract def ordered: Boolean

the ordered behaviour

abstract def writeConcern: commands.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[UpdateCommand.UpdateElement]

Prepares an UpdateCommand.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[UpdateCommand.UpdateElement]

Prepares an UpdateCommand.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[UpdateCommand.UpdateElement]

Prepares an UpdateCommand.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[UpdateCommand.UpdateElement])(implicit ec: ExecutionContext): Future[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 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[UpdateWriteResult]

Performs a single update (see UpdateCommand.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[UpdateWriteResult]

Performs a single update (see UpdateCommand.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[UpdateWriteResult]

Performs a single update (see UpdateCommand.UpdateElement).

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)