DeleteBuilder

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

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.DeleteBuilder, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def element[Q, U](q: Q, limit: Option[Int] = None, collation: Option[Collation] = None)(implicit qw: P.Writer[Q]): Future[GenericCollection.DeleteElement]

Prepares an DeleteElement.

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

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

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

def ensuring(cond: Boolean): GenericCollection.DeleteBuilder

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(deletes: Iterable[GenericCollection.DeleteElement])(implicit ec: ExecutionContext): Future[GenericCollection.MultiBulkWriteResult]

Performs a bulk operation using many deletes, each can delete multiple documents.

import scala.concurrent.{ ExecutionContext, Future }

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

def bulkDelete(
  coll: BSONCollection,
  docs: Iterable[BSONDocument])(implicit ec: ExecutionContext) = {
  val delete = coll.delete(ordered = true)
  val elements = Future.sequence(docs.map { doc =>
    delete.element(
      q = doc,
      limit = Some(1)) // only first match
  })

  elements.flatMap { ops =>
    delete.many(ops) // Future[MultiBulkWriteResult]
  }
}

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def one[Q, U](q: Q, limit: Option[Int] = None, collation: Option[Collation] = None)(implicit ec: ExecutionContext, qw: P.Writer[Q]): Future[WriteResult]

Performs a delete with a one single selector (see DeleteElement).

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.DeleteBuilder, B)