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: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Prepares an BatchCommands.DeleteCommand.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[DeleteElement])(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

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

import reactivemongo.bson.BSONDocument
import reactivemongo.api.collections.BSONCollection

def bulkDelete(coll: BSONCollection, docs: Iterable[BSONDocument]) = {
  val delete = coll.delete(ordered = true)
  val elements = docs.map { doc =>
    delete.element(
      q = BSONDocument("filter" -> "value"),
      limit = Some(1)) // only first match
  }

  delete.many(elements) // 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 BatchCommands.DeleteCommand.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)

val self: Any

val self: Any

def x: GenericCollection.DeleteBuilder

def x: GenericCollection.DeleteBuilder