DB

abstract def abortTransaction(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Aborts the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .

abstract def commitTransaction(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Commits the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def commitIt(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.commitTransaction(failIfNotStarted = true)

abstract def connection: MongoConnection

The reactivemongo.api.MongoConnection that will be used to query this database.

abstract def endSession(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Ends (closes) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .

abstract def failoverStrategy: FailoverStrategy

A failover strategy for sending requests.

abstract def killSession(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Kills (aborts) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .

abstract def name: String

This database name.

abstract def startSession(failIfAlreadyStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Starts a new session (since MongoDB 3.6).

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def startIt(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.startSession(failIfAlreadyStarted = true)

abstract def startTransaction(writeConcern: Option[WriteConcern], failIfAlreadyStarted: Boolean)(implicit ec: ExecutionContext): Future[DBType]

Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.

import scala.concurrent.ExecutionContext
import reactivemongo.api.{ DefaultDB, WriteConcern }

def doIt(db: DefaultDB, aWriteConcern: Option[WriteConcern])(
  implicit ec: ExecutionContext) =
  db.startTransaction(aWriteConcern, failIfAlreadyStarted = true)

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (DB, B)

final def ==(arg0: Any): Boolean

final def abortTransaction()(implicit ec: ExecutionContext): Future[DBType]

Aborts the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def equivalentTo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.abortTransaction(failIfNotStarted = false)

def apply[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): C

Returns a reactivemongo.api.Collection reference from this database (alias for the collection method).

final def asInstanceOf[T0]: T0

def authenticate(user: String, password: String)(implicit ec: ExecutionContext): Future[SuccessfulAuthentication]

Authenticates the connection on this database.

def clone(): AnyRef

def collection[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): C

Returns a reactivemongo.api.Collection reference from this database.

final def commitTransaction()(implicit ec: ExecutionContext): Future[DBType]

Commits the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def equivalentTo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.commitTransaction(failIfNotStarted = false)

final def endSession()(implicit ec: ExecutionContext): Future[DBType]

Ends (closes) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def equivalentTo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.endSession(failIfNotStarted = false)

def ensuring(cond: (DB) ⇒ Boolean, msg: ⇒ Any): DB

def ensuring(cond: (DB) ⇒ Boolean): DB

def ensuring(cond: Boolean, msg: ⇒ Any): DB

def ensuring(cond: Boolean): DB

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 killSession()(implicit ec: ExecutionContext): Future[DBType]

Kills (aborts) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def equivalentTo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.killSession(failIfNotStarted = false)

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def startSession()(implicit ec: ExecutionContext): Future[DBType]

Starts a new session (since MongoDB 3.6), does nothing if a session has already being started .

import scala.concurrent.ExecutionContext
import reactivemongo.api.DefaultDB

def equivalentTo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.startSession(failIfAlreadyStarted = false)

final def startTransaction(writeConcern: Option[WriteConcern])(implicit ec: ExecutionContext): Future[DBType]

Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.

import scala.concurrent.ExecutionContext
import reactivemongo.api.{ DefaultDB, WriteConcern }

def equivalentTo(db: DefaultDB, aWriteConcern: Option[WriteConcern])(
  implicit ec: ExecutionContext) =
  db.startTransaction(aWriteConcern, failIfAlreadyStarted = false)

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): (DB, B)

def defaultReadPreference: ReadPreference

def sibling(name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit ec: ExecutionContext): DefaultDB

Returns the database of the given name on the same MongoConnection.

def sibling1(name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit ec: ExecutionContext): Future[DefaultDB]

Returns the database of the given name on the same MongoConnection.