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
- All
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] = ...): 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( ... ) @native()
-
def
collection[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): 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: Any): 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[_]
- 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] = ...): 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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def →[B](y: B): (DB, B)