DefaultDB

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

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 .

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 canEqual(that: Any): Boolean

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.

def collectionNames(implicit ec: ExecutionContext): Future[List[String]]

Returns the names of the collections in this database.

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

def listCollections(db: DefaultDB)(
  implicit ec: ExecutionContext): Future[List[String]] =
  db.collectionNames

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)

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)

val connection: MongoConnection

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

val connectionState: ConnectionState

The state of the associated connection

def createUser[T](user: String, pwd: Option[String], customData: Option[T], roles: List[UserRole], digestPassword: Boolean, writeConcern: commands.WriteConcern, restrictions: List[AuthenticationRestriction], mechanisms: List[AuthenticationMode])(implicit ec: ExecutionContext, w: DBMetaWriter[T]): Future[Unit]

Create the user with given properties.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.{
  DefaultDB,
  ScramSha256Authentication,
  ScramSha1Authentication,
  WriteConcern
}
import reactivemongo.api.commands.UserRole

def createReadWriteUser(db: DefaultDB, name: String)(
  implicit ec: ExecutionContext): Future[Unit] =
  db.createUser(
    user = name,
    pwd = None, // no initial password
    customData = None, // no custom data
    roles = List(UserRole("readWrite")),
    digestPassword = true,
    writeConcern = WriteConcern.Default,
    restrictions = List.empty,
    mechanisms = List(
      ScramSha1Authentication, ScramSha256Authentication))

def drop()(implicit ec: ExecutionContext): Future[Unit]

Drops this database.

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

def dropDB(db: DefaultDB)(
  implicit ec: ExecutionContext): Future[Unit] = db.drop()

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

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

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: (DefaultDB) ⇒ Boolean, msg: ⇒ Any): DefaultDB

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

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

def ensuring(cond: Boolean): DefaultDB

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val failoverStrategy: FailoverStrategy

A failover strategy for sending requests.

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def indexesManager(implicit ec: ExecutionContext): Aux[Pack]

Returns an index manager for this database.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.DefaultDB
import reactivemongo.api.indexes.NSIndex

def listIndexes(db: DefaultDB)(
  implicit ec: ExecutionContext): Future[List[String]] =
  db.indexesManager.list().map(_.flatMap { ni: NSIndex =>
    ni.index.name.toList
  })

final def isInstanceOf[T0]: Boolean

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

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

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)

val name: String

This database name.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val pack: Pack

def ping(readPreference: ReadPreference = ReadPreference.nearest)(implicit ec: ExecutionContext): Future[Boolean]

Tests if the server, resolved according to the given read preference, responds to commands.

def productIterator: Iterator[Any]

def productPrefix: String

def renameCollection[C <: Collection](db: String, from: String, to: String, dropExisting: Boolean = false, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit ec: ExecutionContext, producer: CollectionProducer[C] = ...): Future[C]

Renames a collection.

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

def addCollSuffix(
  admin: DefaultDB,
  coll: String,
  suffix: String)(implicit ec: ExecutionContext): Future[Unit] =
  admin.renameCollection("myDB", coll, coll + suffix).map(_ => {})

def runCommand(command: Document, failoverStrategy: FailoverStrategy): CursorFetcher[pack.type, Cursor]

Run a raw command (represented by a document).

import reactivemongo.api.FailoverStrategy
import reactivemongo.api.bson.BSONDocument

def getUsers(db: reactivemongo.api.DefaultDB) =
  db.runCommand(BSONDocument("usersInfo" -> 1), FailoverStrategy.default)

def runCommand[C <: Command](command: C, failoverStrategy: FailoverStrategy)(implicit writer: Writer[C]): CursorFetcher[pack.type, Cursor]

def runCommand[R, C <: Command with CommandWithResult[R]](command: C with CommandWithResult[R], failoverStrategy: FailoverStrategy)(implicit writer: Writer[C], reader: Reader[R], ec: ExecutionContext): Future[R]

def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: Command with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]], failoverStrategy: FailoverStrategy, readPreference: ReadPreference)(implicit writer: Writer[C], reader: Reader[R], ec: ExecutionContext): Future[A]

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

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)

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)

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

def createUser(user: String, pwd: Option[String], customData: Option[BSONDocument], roles: List[UserRole], digestPassword: Boolean, writeConcern: commands.WriteConcern, restrictions: List[AuthenticationRestriction], mechanisms: List[AuthenticationMode])(implicit ec: ExecutionContext): Future[Unit]

def createUser(user: String, pwd: Option[String], roles: List[UserRole], digestPassword: Boolean = true, writeConcern: commands.WriteConcern = connection.options.writeConcern, customData: Option[BSONDocument] = None)(implicit ec: ExecutionContext): Future[Unit]

def defaultReadPreference: ReadPreference

val productArity: Int

def productElement(n: Int): Any

def serverStatus(implicit ec: ExecutionContext): Future[ServerStatusResult]

Returns the server status.

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.