The asynchronous driver (see MongoConnection).
The mode/mechanism of authentication
Represents a collection, view, index or operation specific collation.
Represents a collection, view, index or operation specific collation.
import reactivemongo.api.Collation val collation = Collation( locale = "en-US", caseLevel = None, caseFirst = None, strength = Some(Collation.PrimaryStrength), numericOrdering = None, alternate = None, maxVariable = None, backwards = None)
Basic information resolved for a MongoDB Collection, resolved from a reactivemongo.api.DB.
Basic information resolved for a MongoDB Collection, resolved from a reactivemongo.api.DB.
For collection operations, you should consider the generic API (reactivemongo.api.collections.GenericCollection).
A Producer of Collection implementation.
A Producer of Collection implementation.
This is used to get an implementation implicitly when getting a reference of a Collection.
Various information about a collection.
Cursor over results from MongoDB.
Cursor over results from MongoDB.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.Cursor import reactivemongo.api.bson.{ BSONDocument, Macros } import reactivemongo.api.bson.collection.BSONCollection case class User(name: String, pass: String) implicit val handler = Macros.reader[User] def findUsers(coll: BSONCollection)( implicit ec: ExecutionContext): Future[List[User]] = coll.find(BSONDocument("enabled" -> true)). cursor[User](). // obtain cursor for User results collect[List]( maxDocs = 10, err = Cursor.FailOnError[List[User]]())
the type parsed from each result document
Flattening strategy for cursor.
Flattening strategy for cursor.
import scala.concurrent.Future import reactivemongo.api.{ Cursor, CursorFlattener } trait FooCursor[T] extends Cursor[T] { def foo: String } def flatFoo[T](future: Future[FooCursor[T]])(implicit cf: CursorFlattener[FooCursor]): FooCursor[T] = Cursor.flatten(future)
Internal cursor operations.
Allows to enrich a base cursor.
The reference to a MongoDB database, obtained from a reactivemongo.api.MongoConnection.
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 }
A failover strategy for sending requests.
A failover strategy for sending requests. The default uses 10 retries: 125ms, 250ms, 375ms, 500ms, 625ms, 750ms, 875ms, 1s, 1125ms, 1250ms
import scala.concurrent.duration._ reactivemongo.api.FailoverStrategy( initialDelay = 150.milliseconds, retries = 20, delayFactor = { `try` => `try` * 1.5D })
A pool of MongoDB connections, obtained from a reactivemongo.api.AsyncDriver.
A pool of MongoDB connections, obtained from a reactivemongo.api.AsyncDriver.
Connection here does not mean that there is one open channel to the server: behind the scene, many connections (channels) are open on all the available servers in the replica set.
Example:
import scala.concurrent.ExecutionContext import reactivemongo.api._ def foo(driver: AsyncDriver)(implicit ec: ExecutionContext) = { val con = driver.connect(List("localhost")) val db = con.flatMap(_.database("plugin")) val _ = db.map(_("acoll")) // Collection reference }
Options for MongoConnection (see more documentation).
Options for MongoConnection (see more documentation).
The Read Concern allows to control the consistency and isolation used to read data from replica sets.
The Read Concern allows to control the consistency and isolation used to read data from replica sets.
import reactivemongo.api.ReadConcern import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def queryBuilderWithReadConcern(coll: BSONCollection) = coll.find(BSONDocument.empty). readConcern(ReadConcern.Available)
MongoDB read preference enables to read from primary or secondaries with a predefined strategy.
MongoDB read preference enables to read from primary or secondaries with a predefined strategy.
import reactivemongo.api.ReadPreference val pref: ReadPreference = ReadPreference.primary
Cursor wrapper, to help to define custom cursor classes.
Cursor wrapper, to help to define custom cursor classes.
CursorProducer
Internal cursor operations.
The write concern.
The write concern.
import scala.concurrent.ExecutionContext import reactivemongo.api.{ DB, WriteConcern } import reactivemongo.api.bson.BSONDocument def foo(db: DB)(implicit ec: ExecutionContext) = db.collection("myColl"). insert(ordered = false, WriteConcern.Acknowledged). one(BSONDocument("foo" -> "bar"))
The driver factory
Change stream utilities.
Change stream utilities.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.ChangeStreams.FullDocumentStrategy import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def peekNext( coll: BSONCollection, strategy: FullDocumentStrategy)( implicit ec: ExecutionContext): Future[Option[BSONDocument]] = coll.watch[BSONDocument](fullDocumentStrategy = Some(strategy)). cursor.headOption def doIt(coll: BSONCollection)( implicit ec: ExecutionContext): Future[Unit] = for { _ <- peekNext(coll, FullDocumentStrategy.Default) _ <- peekNext(coll, FullDocumentStrategy.UpdateLookup) } yield ()
Collation utilities.
Cursor companion object
Flatteners helper
FailoverStrategy utilities
MongoConnectionOptions factory.
MongoConnectionOptions factory.
reactivemongo.api.MongoConnectionOptions(nbChannelsPerNode = 10)
ReadPreference utilities and factories.
SCRAM-SHA-1 authentication (since MongoDB 3.6)
SCRAM-SHA-256 authentication (see MongoDB 4.0)
WriteConcern utilities.
X509 authentication
The asynchronous driver (see MongoConnection).