final class DB extends DBMetaCommands with PackSupport[Pack]
The reference to a MongoDB database, obtained from a reactivemongo.api.MongoConnection.
import scala.concurrent.ExecutionContext import reactivemongo.api.MongoConnection def foo(connection: MongoConnection)(implicit ec: ExecutionContext) = { val db = connection.database("plugin") val _ = db.map(_("acoll")) // Collection reference }
- Alphabetic
- By Inheritance
- DB
- PackSupport
- DBMetaCommands
- CreateUserCommand
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Type Members
- final class CreateUser extends Command with CommandWithPack[P] with CommandWithResult[Unit]
The createUser command.
The createUser command.
- Attributes
- protected
- Definition Classes
- CreateUserCommand
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (DB, B)
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def abortTransaction(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Aborts the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .
Aborts the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .
- returns
The database reference with transaction aborted (but not session)
- def abortTransaction()(implicit ec: ExecutionContext): Future[DB]
Aborts the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .
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.DB def equivalentTo(db: DB)(implicit ec: ExecutionContext) = db.abortTransaction(failIfNotStarted = false)
- returns
The database reference with transaction aborted (but not session)
- Annotations
- @inline()
- def apply[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = Serialization.defaultCollectionProducer): C
Returns a reactivemongo.api.Collection reference from this database (alias for the collection method).
Returns a reactivemongo.api.Collection reference from this database (alias for the collection method).
- C
the Collection type
- name
the name of the collection to resolve
- failoverStrategy
the failover strategy to override the default one
- Annotations
- @SuppressWarnings()
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def authenticate(user: String, password: String)(implicit ec: ExecutionContext): Future[SuccessfulAuthentication]
Authenticates the connection on this database.
Authenticates the connection on this database.
- user
the name of the user
- password
the user password
- See also
MongoConnection.authenticate
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collection[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = Serialization.defaultCollectionProducer): C
Returns a reactivemongo.api.Collection reference from this database.
Returns a reactivemongo.api.Collection reference from this database.
- C
the Collection type
- name
the name of the collection to resolve
- failoverStrategy
the failover strategy to override the default one
import reactivemongo.api.DB def resolveColl(db: DB) = db.collection("acoll")
- Annotations
- @SuppressWarnings()
- final def collectionNames(implicit ec: ExecutionContext): Future[List[String]]
Returns the names of the collections in this database.
Returns the names of the collections in this database.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.DB def listCollections(db: DB)( implicit ec: ExecutionContext): Future[List[String]] = db.collectionNames
- Definition Classes
- DBMetaCommands
- def commitTransaction(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Commits the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .
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.DB def commitIt(db: DB)(implicit ec: ExecutionContext) = db.commitTransaction(failIfNotStarted = true)
- returns
The database reference with transaction commited (but not session)
- def commitTransaction()(implicit ec: ExecutionContext): Future[DB]
Commits the transaction associated with the current client session (since MongoDB 4.0), if any otherwise does nothing .
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.DB def equivalentTo(db: DB)(implicit ec: ExecutionContext) = db.commitTransaction(failIfNotStarted = false)
- returns
The database reference with transaction commited (but not session)
- Annotations
- @inline()
- val connection: MongoConnection
- final def createUser[T](user: String, pwd: Option[String], customData: Option[T] = Option.empty[Pack#Document], roles: List[UserRole] = List.empty, digestPassword: Boolean = true, writeConcern: WriteConcern = connection.options.writeConcern, restrictions: List[AuthenticationRestriction] = List.empty, mechanisms: List[AuthenticationMode] = List.empty)(implicit ec: ExecutionContext, w: Writer[T]): Future[Unit]
Create the user with given properties.
Create the user with given properties.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.{ DB, ScramSha256Authentication, ScramSha1Authentication, WriteConcern } import reactivemongo.api.commands.UserRole def createReadWriteUser(db: DB, name: String)( implicit ec: ExecutionContext): Future[Unit] = db.createUser( user = name, pwd = None, // no initial password roles = List(UserRole("readWrite")), digestPassword = true, writeConcern = WriteConcern.Default, restrictions = List.empty, mechanisms = List( ScramSha1Authentication, ScramSha256Authentication))
- T
the type of custom data associated with the created user
- user
the name of the user to be created
- pwd
the user password (not required if the database uses external credentials)
- customData
the custom data to associate with the user account
- roles
the roles granted to the user, possibly an empty to create users without roles
- digestPassword
when true, the mongod instance will create the hash of the user password (default:
true
)- writeConcern
the optional level of write concern
- restrictions
the authentication restriction
- mechanisms
the authentication mechanisms (e.g. ScramSha1Authentication)
- Definition Classes
- DBMetaCommands
- final def createUserWriter(version: MongoWireVersion): Writer[CreateUser]
- Attributes
- protected
- Definition Classes
- CreateUserCommand
- final def drop()(implicit ec: ExecutionContext): Future[Unit]
Drops this database.
Drops this database.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.DB def dropDB(db: DB)( implicit ec: ExecutionContext): Future[Unit] = db.drop()
- Definition Classes
- DBMetaCommands
- def endSession(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Ends (closes) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
Ends (closes) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
- returns
The database reference with session ended
- def endSession()(implicit ec: ExecutionContext): Future[DB]
Ends (closes) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
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.DB def equivalentTo(db: DB)(implicit ec: ExecutionContext) = db.endSession(failIfNotStarted = false)
- returns
The database reference with session ended
- Annotations
- @inline()
- 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
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- val failoverStrategy: FailoverStrategy
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def formatted(fmtstr: String): String
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getMore[P <: SerializationPack, T](pack: P, reference: Reference, readPreference: ReadPreference = defaultReadPreference, failoverStrategy: FailoverStrategy = this.failoverStrategy, maxTimeMS: Option[Long] = None)(implicit reader: getMore.P.Reader[T], cp: CursorProducer[T]): ProducedCursor
EXPERIMENTAL: API may change without notice.
EXPERIMENTAL: API may change without notice.
- Annotations
- @SuppressWarnings()
- final def gridfs[P <: SerializationPack](pack: P, prefix: String): GridFS[P]
The GridFS with the default serialization.
The GridFS with the default serialization.
- P
the type of serialization
- pack
the serialization pack
- prefix
the collection prefix
- Definition Classes
- DBMetaCommands
- final def gridfs(prefix: String): GridFS[Pack]
The GridFS with the default serialization.
The GridFS with the default serialization.
- prefix
the collection prefix
- Definition Classes
- DBMetaCommands
- Annotations
- @inline()
- final def gridfs: GridFS[Pack]
The GridFS with the default serialization and collection prefix.
The GridFS with the default serialization and collection prefix.
import reactivemongo.api.DB import reactivemongo.api.bson.BSONDocument def findFile(db: DB, query: BSONDocument) = db.gridfs.find(query)
- Definition Classes
- DBMetaCommands
- Annotations
- @inline()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def indexesManager(implicit ec: ExecutionContext): Aux[Pack]
Returns an index manager for this database.
Returns an index manager for this database.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.DB import reactivemongo.api.indexes.NSIndex def listIndexes(db: DB)( implicit ec: ExecutionContext): Future[List[String]] = db.indexesManager.list().map(_.flatMap { ni: NSIndex => ni.index.name.toList })
- Definition Classes
- DBMetaCommands
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def killSession(failIfNotStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Kills (aborts) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
Kills (aborts) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
- returns
The database reference with session aborted
- def killSession()(implicit ec: ExecutionContext): Future[DB]
Kills (aborts) the session associated with this database reference (since MongoDB 3.6), if any otherwise does nothing .
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.DB def equivalentTo(db: DB)(implicit ec: ExecutionContext) = db.killSession(failIfNotStarted = false)
- returns
The database reference with session aborted
- Annotations
- @inline()
- val name: String
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- val pack: Pack
The serialization pack (BSON by default).
- final 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.
Tests if the server, resolved according to the given read preference, responds to commands.
- returns
true if successful (even if the server is write locked)
- Definition Classes
- DBMetaCommands
- Since
MongoDB 3.0
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.DB def pingDB(db: DB)( implicit ec: ExecutionContext): Future[Boolean] = db.ping() // with default ReadPreference
- final def renameCollection[C <: Collection](db: String, from: String, to: String, dropExisting: Boolean = false, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit ec: ExecutionContext, producer: CollectionProducer[C] = Serialization.defaultCollectionProducer): Future[C]
Renames a collection. Can only be executed if the this database reference is the
admin
one.import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.DB def addCollSuffix( admin: DB, coll: String, suffix: String)(implicit ec: ExecutionContext): Future[Unit] = admin.renameCollection("myDB", coll, coll + suffix).map(_ => {})
- db
the name of the database where the collection exists with the
current
name- from
the current name of the collection, in the specified
db
- to
the new name of this collection (inside the same
db
)- dropExisting
If a collection of name
to
already exists, then drops that collection before renaming this one.- returns
a failure if the dropExisting option is false and the target collection already exists
- Definition Classes
- DBMetaCommands
- def runCommand(command: Document, failoverStrategy: FailoverStrategy): CursorFetcher[pack.type, Cursor]
Run a raw command (represented by a document).
Run a raw command (represented by a document).
import reactivemongo.api.FailoverStrategy import reactivemongo.api.bson.BSONDocument def getUsers(db: reactivemongo.api.DB) = db.runCommand(BSONDocument("usersInfo" -> 1), FailoverStrategy.default)
- command
the command to be executed on the current database
- failoverStrategy
the failover strategy to override the default one
- returns
A cursor for the command results
- Annotations
- @SuppressWarnings()
- def runCommand[C <: Command](command: C, failoverStrategy: FailoverStrategy)(implicit writer: Writer[C]): CursorFetcher[pack.type, Cursor]
- C
the reactivemongo.api.commands.Command type
- command
the command to be executed on the current database
- failoverStrategy
the failover strategy to override the default one
- writer
the writer for the command
- returns
A cursor for the command results
- Annotations
- @SuppressWarnings()
- def runCommand[R, C <: Command with CommandWithResult[R]](command: C with CommandWithResult[R], failoverStrategy: FailoverStrategy = FailoverStrategy.default, readPreference: ReadPreference = this.defaultReadPreference)(implicit writer: Writer[C], reader: Reader[R], ec: ExecutionContext): Future[R]
- R
the result type
- C
the reactivemongo.api.commands.Command type
- command
the command to be executed on the current database
- failoverStrategy
the failover strategy to override the default one
- readPreference
the read preference for the result
- writer
the writer for the command
- reader
the reader for the result of command execution
- returns
A single result from command execution
- Annotations
- @SuppressWarnings()
- def startSession(failIfAlreadyStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Starts a new session (since MongoDB 3.6).
Starts a new session (since MongoDB 3.6).
import scala.concurrent.ExecutionContext import reactivemongo.api.DB def startIt(db: DB)(implicit ec: ExecutionContext) = db.startSession(failIfAlreadyStarted = true)
- failIfAlreadyStarted
if true fails if a session is already started
- returns
The database reference updated with a new session, if none is already started with the current reference.
- def startSession()(implicit ec: ExecutionContext): Future[DB]
Starts a new session (since MongoDB 3.6), does nothing if a session has already being started .
Starts a new session (since MongoDB 3.6), does nothing if a session has already being started .
import scala.concurrent.ExecutionContext import reactivemongo.api.DB def equivalentTo(db: DB)(implicit ec: ExecutionContext) = db.startSession(failIfAlreadyStarted = false)
- returns
The database reference updated with a new session
- Annotations
- @inline()
- def startTransaction(writeConcern: Option[WriteConcern], failIfAlreadyStarted: Boolean)(implicit ec: ExecutionContext): Future[DB]
Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.
Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.
It fails if no session is previously started (see
startSession
).import scala.concurrent.ExecutionContext import reactivemongo.api.{ DB, WriteConcern } def doIt(db: DB, aWriteConcern: Option[WriteConcern])( implicit ec: ExecutionContext) = db.startTransaction(aWriteConcern, failIfAlreadyStarted = true)
- writeConcern
the write concern for the transaction operation
- returns
The database reference with transaction.
- def startTransaction(writeConcern: Option[WriteConcern])(implicit ec: ExecutionContext): Future[DB]
Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.
Starts a transaction (since MongoDB 4.0), if none is already started with the current client session otherwise does nothing.
It fails if no session is previously started (see
startSession
).import scala.concurrent.ExecutionContext import reactivemongo.api.{ DB, WriteConcern } def equivalentTo(db: DB, aWriteConcern: Option[WriteConcern])( implicit ec: ExecutionContext) = db.startTransaction(aWriteConcern, failIfAlreadyStarted = false)
- writeConcern
the write concern for the transaction operation
- returns
The database reference with transaction.
- Annotations
- @inline()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- DB → AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- def →[B](y: B): (DB, B)
- Implicit
- This member is added by an implicit conversion from DB toArrowAssoc[DB] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.