The database which this collection belongs to.

The name of the collection.

The serialization pack (BSON by default).

Used to resolve the types of values (by default BSONValue, BSONDocument, ...), and the related typeclasses (e.g. BSONDocumentReader ...).

The default read preference

The aggregation framework for this collection

Aggregates the matching documents.

Aggregates the matching documents.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

import reactivemongo.api.Cursor
import reactivemongo.api.bson._
import reactivemongo.api.bson.collection.BSONCollection

def populatedStates(cities: BSONCollection): Future[List[BSONDocument]] = {
  import cities.AggregationFramework
  import AggregationFramework.{ Group, Match, SumField }

  cities.aggregatorContext[BSONDocument](
    List(Group(BSONString(f"$$state"))(
      "totalPop" -> SumField("population")),
        Match(BSONDocument("totalPop" ->
          BSONDocument(f"$$gte" -> 10000000L))))
  ).prepared.cursor.collect[List](
    maxDocs = 3,
    err = Cursor.FailOnError[List[BSONDocument]]()
  )
}

Converts this collection to a capped one.

import scala.concurrent.{ ExecutionContext, Future }

def capColl(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.convertToCapped(size = 10L, maxDocuments = Some(100))

Counts the matching documents.

Creates this collection.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.collections.GenericCollection

def createIfNotExists(coll: GenericCollection[_])(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.create(failsIfExists = true)

Creates this collection.

The returned future will be completed, with an error if this collection already exists.

import scala.concurrent.ExecutionContext

import reactivemongo.api.collections.GenericCollection
import reactivemongo.api.commands.CommandException

def createColl(
  coll: GenericCollection[_])(implicit ec: ExecutionContext) =
  coll.create().recover {
    case CommandException.Code(48) => // NamespaceExists
      println(s"Collection \${coll} already exists")
  }

Creates this collection as a capped one.

The returned future will be completed with an error if this collection already exists.

import scala.concurrent.{ ExecutionContext, Future }

def capped(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.createCapped(size = 10, maxDocuments = Some(100))

Creates a view on this collection, using an aggregation pipeline.

Prepares a delete builder.

Prepares an unordered delete builder.

import scala.concurrent.ExecutionContext

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def doIt(coll: BSONCollection, query: BSONDocument)(
  implicit ec: ExecutionContext) = coll.delete.one(query)

def equivalentTo(coll: BSONCollection) = coll.delete(false)

Returns the distinct values for a specified field across a single collection.

Drops this collection.

If the collection existed and is successfully dropped, the returned future will be completed with true.

If failIfNotFound is false and the collection doesn't exist, the returned future will be completed with false.

Otherwise in case, the future will be completed with the encountered error.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.collections.GenericCollection

def dropIfNotFound(coll: GenericCollection[_])(
  implicit ec: ExecutionContext): Future[Boolean] =
  coll.drop(failIfNotFound = true)

Drops this collection.

The returned future will be completed with an error if this collection does not exist.

Finds the documents matching the given criteria (selector), with the projection applied.

Finds the documents matching the given criteria (selector), with the projection applied.

Applies a findAndModify operation. See findAndUpdate and findAndRemove convenient functions.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.bson.{ BSONDocument, BSONDocumentReader }
import reactivemongo.api.bson.collection.BSONCollection

case class Person(name: String, age: Int)

def foo(coll: BSONCollection)(
  implicit ec: ExecutionContext, r: BSONDocumentReader[Person]) = {
  val updateOp = coll.updateModifier(
    BSONDocument(f"$$set" -> BSONDocument("age" -> 35)))

  val personBeforeUpdate: Future[Option[Person]] =
    coll.findAndModify(BSONDocument("name" -> "Joline"), updateOp).
    map(_.result[Person])

  val removedPerson: Future[Option[Person]] = coll.findAndModify(
    BSONDocument("name" -> "Jack"), coll.removeModifier).
    map(_.result[Person])

  val _ = List(personBeforeUpdate, removedPerson)
}

Finds some matching document, and removes it (using findAndModify).

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.bson.{ BSONDocument, BSONDocumentReader }
import reactivemongo.api.bson.collection.BSONCollection

case class Person(name: String, age: Int)

def removed(coll: BSONCollection)(
  implicit ec: ExecutionContext,
  r: BSONDocumentReader[Person]): Future[Option[Person]] =
  coll.findAndRemove(
    BSONDocument("name" -> "Foo")).map(_.result[Person])

Finds some matching document, and updates it (using findAndModify).

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def findPerson(coll: BSONCollection)(
  implicit ec: ExecutionContext): Future[Option[BSONDocument]] =
  coll.findAndUpdate(
    BSONDocument("name" -> "James"),
    BSONDocument(f"$$set" -> BSONDocument("age" -> 17)),
    fetchNewObject = true).map(_.value)
    // on success, return the update document: { "age": 17 }

Returns a hint for the given index specification document.

Returns a hint for the given index name.

Returns an index manager for this collection.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.collections.GenericCollection

def listIndexes(coll: GenericCollection[_])(
  implicit ec: ExecutionContext): Future[List[String]] =
  coll.indexesManager.list().map(_.flatMap { idx =>
    idx.name.toList
  })

Returns a builder for insert operations.

Returns a builder for insert operations. Uses the default write concern.

Returns a builder for insert operations.

Returns an ordered builder for insert operations.

Returns a builder for insert operations. Uses the default write concern.

Returns an unordered builder for insert operations. Uses the default write concern.

The default read concern

Returns a removal modifier, to be used with findAndModify.

The command runner

Returns various information about this collection.

import scala.concurrent.{ ExecutionContext, Future }

def getSize(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Double] =
  coll.stats(scale = 1024).map(_.size)

Returns various information about this collection.

import scala.concurrent.{ ExecutionContext, Future }

def isCapped(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Boolean] =
  coll.stats().map(_.capped)

Returns an update builder.

import scala.concurrent.ExecutionContext

import reactivemongo.api.WriteConcern
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def myUpdate(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument,
  wc: WriteConcern
)(implicit ec: ExecutionContext) = coll.update(
  ordered = false,
  writeConcern = wc,
  bypassDocumentValidation = true
).one(query, update)

Returns an update builder. Uses the default write concern.

import scala.concurrent.ExecutionContext

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def withDefaultWriteConcern(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument
)(implicit ec: ExecutionContext) = coll.update(
  ordered = false,
  bypassDocumentValidation = true
).one(query, update)

Returns an update builder.

import scala.concurrent.ExecutionContext

import reactivemongo.api.WriteConcern
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def myUpdate(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument,
  wc: WriteConcern
)(implicit ec: ExecutionContext) =
  coll.update(ordered = false, writeConcern = wc).one(query, update)

Returns an ordered update builder.

import scala.concurrent.ExecutionContext

import reactivemongo.api.WriteConcern
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def orderedUpdate(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument,
  wc: WriteConcern
)(implicit ec: ExecutionContext) =
  coll.update(writeConcern = wc).one(query, update)

Returns an update builder. Uses the default write concern.

import scala.concurrent.ExecutionContext

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def withDefaultWriteConcern(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument
)(implicit ec: ExecutionContext) = {
  coll.update(ordered = true).
    one(query, update, upsert = false, multi = false)
}

Returns an unordered update builder. Uses the default write concern.

import scala.concurrent.ExecutionContext

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def withDefaultWriteConcern(
  coll: BSONCollection,
  query: BSONDocument,
  update: BSONDocument
)(implicit ec: ExecutionContext) = {
  coll.update.one(query, update, upsert = false, multi = false)
}

Returns an update modifier, to be used with findAndModify.

Upper MongoDB version (used for version checks)

EXPERIMENTAL: Prepares a builder for watching the change stream of this collection.

Note: The target mongo instance MUST be a replica-set (even in the case of a single node deployement).

import reactivemongo.api.Cursor
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def events(coll: BSONCollection): Cursor[BSONDocument] =
  coll.watch[BSONDocument]().cursor

The default write concern

The read preference for the write operations (primary)

Remove (part of a FindAndModify command).