The asynchronous driver (see MongoConnection).

import scala.concurrent.Future
import reactivemongo.api.{ AsyncDriver, MongoConnection }

val driver = AsyncDriver()
val connection: Future[MongoConnection] =
  driver.connect("mongodb://node:27017")

Represents a collection, view, index or operation specific collation.

import reactivemongo.api.Collation

val collation = new Collation(
  locale = "en-US",
  caseLevel = None,
  caseFirst = None,
  strength = Some(Collation.PrimaryStrength),
  numericOrdering = None,
  alternate = None,
  maxVariable = None,
  backwards = None)

A MongoDB Collection, resolved from a reactivemongo.api.DefaultDB.

You should consider the generic API (reactivemongo.api.collections.GenericCollection).

A Producer of Collection implementation.

This is used to get an implementation implicitly when getting a reference of a Collection.

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]]())

Cursor over results from MongoDB.

Flattening strategy for cursor.

import scala.concurrent.Future

import reactivemongo.api.{ Cursor, CursorFlattener, FlattenedCursor }

trait FooCursor[T] extends Cursor[T] { def foo: String }

implicit def fooFlattener = new CursorFlattener[FooCursor] {
  def flatten[T](future: Future[FooCursor[T]]): FooCursor[T] =
    new FlattenedCursor[T](future) with FooCursor[T] {
      def foo = "Flattened"
    }
}

The reference to a MongoDB database, obtained from a reactivemongo.api.MongoConnection.

You should consider the provided reactivemongo.api.DefaultDB implementation.

import scala.concurrent.ExecutionContext
import reactivemongo.api.MongoConnection

def foo(connection: MongoConnection)(implicit ec: ExecutionContext) = {
  val db = connection.database("plugin")
  val collection = db.map(_("acoll"))
}

The default DB implementation, that mixes in the database traits.

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.MongoDriver.

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 collection = db.map(_("acoll"))
}

The Read Concern allows to control the consistency and isolation used to read data from replica sets.

import scala.concurrent.ExecutionContext

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.

import reactivemongo.api.ReadPreference

val pref: ReadPreference = ReadPreference.primary

Cursor wrapper, to help to define custom cursor classes.

The write concern.

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

def foo(db: DefaultDB)(implicit ec: ExecutionContext) =
  db.collection("myColl").
    insert(ordered = false, WriteConcern.Acknowledged).
    one(BSONDocument("foo" -> "bar"))

A mixin that provides commands about this Collection itself.

A mixin that provides commands about this database itself.

A helper that sends the given message to the given actor, following a failover strategy. This helper holds a future reference that is completed with a response, after 1 or more attempts (specified in the given strategy). If the all the tryouts configured by the given strategy were unsuccessful, the future reference is completed with a Throwable.

Should not be used directly for most use cases.

A helper to make the query options. You may use the methods to set the fields of this class, or set them directly.