Trait

reactivemongo.api.collections

GenericCollection

Related Doc: package collections

Permalink

trait GenericCollection[P <: SerializationPack with Singleton] extends Collection with GenericCollectionWithCommands[P] with CollectionMetaCommands with ImplicitCommandHelpers[P]

A Collection that provides default methods using a SerializationPack (e.g. the default reactivemongo.api.BSONSerializationPack).

Some methods of this collection accept instances of Reader[T] and Writer[T], that transform any T instance into a document, compatible with the selected serialization pack, and vice-versa.

P

the serialization pack

Self Type
GenericCollection[P]
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. GenericCollection
  2. ImplicitCommandHelpers
  3. CollectionMetaCommands
  4. GenericCollectionWithCommands
  5. Collection
  6. AnyRef
  7. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type AggregationFramework = AggregationFramework.type

    Permalink

    Alias for type of the aggregation framework, depending on the type of the collection.

    Alias for type of the aggregation framework, depending on the type of the collection.

    See also

    reactivemongo.api.commands.AggregationFramework

  2. sealed trait BulkMaker[R, S <: BulkMaker[R, S]] extends AnyRef

    Permalink
    Attributes
    protected
  3. trait ImplicitlyDocumentProducer extends AnyRef

    Permalink
    Definition Classes
    ImplicitCommandHelpers
  4. class Mongo26WriteCommand extends BulkMaker[WriteResult, Mongo26WriteCommand]

    Permalink
    Attributes
    protected
  5. type PipelineOperator = commands.AggregationFramework.PipelineOperator

    Permalink

    Alias for BatchCommands.AggregationFramework.PipelineOperator

Abstract Value Members

  1. abstract val BatchCommands: BatchCommands[pack.type]

    Permalink
    Attributes
    protected
  2. abstract def db: DB

    Permalink

    The database which this collection belong to.

    The database which this collection belong to.

    Definition Classes
    Collection
  3. abstract def failoverStrategy: FailoverStrategy

    Permalink

    The default failover strategy for the methods of this collection.

    The default failover strategy for the methods of this collection.

    Definition Classes
    GenericCollectionCollection
  4. abstract def genericQueryBuilder: GenericQueryBuilder[pack.type]

    Permalink
  5. abstract def name: String

    Permalink

    The name of the collection.

    The name of the collection.

    Definition Classes
    Collection
  6. abstract val pack: P

    Permalink
  7. abstract def withReadPreference(pref: ReadPreference): GenericCollection[P]

    Permalink

    Returns a new reference to the same collection, with the given read preference.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to any2stringadd[GenericCollection[P]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (GenericCollection[P], B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to ArrowAssoc[GenericCollection[P]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  6. object ImplicitlyDocumentProducer

    Permalink
    Definition Classes
    ImplicitCommandHelpers
  7. object Mongo26WriteCommand

    Permalink
    Attributes
    protected
  8. implicit def PackIdentityReader: P.Reader[P.Document]

    Permalink
  9. implicit def PackIdentityWriter: P.Writer[P.Document]

    Permalink
  10. def aggregate[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], cursor: Option[commands.AggregationFramework.Cursor], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern], readPreference: ReadPreference)(implicit ec: ExecutionContext, reader: P.Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

    Permalink

    Aggregates the matching documents.

    Aggregates the matching documents.

    import scala.concurrent.Future
    import scala.concurrent.ExecutionContext.Implicits.global
    
    import reactivemongo.bson._
    import reactivemongo.api.Cursor
    import reactivemongo.api.collections.bson.BSONCollection
    
    def populatedStates(cities: BSONCollection): Future[Cursor[BSONDocument]] =
      {
        import cities.BatchCommands.AggregationFramework
        import AggregationFramework.{
          Cursor => AggCursor, Group, Match, SumField
        }
    
        val cursor = AggCursor(batchSize = 1) // initial batch size
    
        cities.aggregate1[BSONDocument](Group(BSONString("$state"))(
          "totalPop" -> SumField("population")), List(
            Match(document("totalPop" ->
              document("$gte" -> 10000000L)))),
          cursor)
      }
    T

    The type of the result elements. An implicit Reader[T] typeclass for handling it has to be in the scope.

    firstOperator

    the first aggregation operator of the pipeline

    otherOperators

    the sequence of MongoDB aggregation operations

    cursor

    aggregation cursor option (optional)

    explain

    if true indicates to return the information on the processing of the pipeline

    allowDiskUse

    if true enables writing to temporary files

    bypassDocumentValidation

    if true enables to bypass document validation during the operation

    readConcern

    the read concern

    readPreference

    the read preference for the result

    reader

    the result reader

    cf

    the cursor flattener (by default use the builtin one)

  11. def aggregate(firstOperator: PipelineOperator, otherOperators: List[PipelineOperator] = Nil, explain: Boolean = false, allowDiskUse: Boolean = false, bypassDocumentValidation: Boolean = false, readConcern: Option[ReadConcern] = None)(implicit ec: ExecutionContext): Future[AggregationResult]

    Permalink

    Aggregates the matching documents.

    Aggregates the matching documents.

    import scala.concurrent.Future
    import scala.concurrent.ExecutionContext.Implicits.global
    
    import reactivemongo.bson._
    import reactivemongo.api.collections.bson.BSONCollection
    
    def populatedStates(cities: BSONCollection): Future[List[BSONDocument]] = {
      import cities.BatchCommands.AggregationFramework
      import AggregationFramework.{ Group, Match, SumField }
    
      cities.aggregate(Group(BSONString("$state"))(
        "totalPop" -> SumField("population")), List(
          Match(document("totalPop" ->
            document("$gte" -> 10000000L))))).map(_.documents)
    }
    firstOperator

    the first aggregation operator of the pipeline

    otherOperators

    the sequence of MongoDB aggregation operations

    explain

    if true indicates to return the information on the processing of the pipeline

    allowDiskUse

    if true enables writing to temporary files

    bypassDocumentValidation

    if true enables to bypass document validation during the operation

    readConcern

    the read concern

  12. def aggregate1[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], explain: Boolean = false, allowDiskUse: Boolean = false, bypassDocumentValidation: Boolean = false, readConcern: Option[ReadConcern] = None, readPreference: ReadPreference = ReadPreference.primary, batchSize: Option[Int] = None)(implicit ec: ExecutionContext, reader: P.Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

    Permalink

    Aggregates the matching documents.

    Aggregates the matching documents.

    T

    The type of the result elements. An implicit Reader[T] typeclass for handling it has to be in the scope.

    firstOperator

    the first aggregation operator of the pipeline

    otherOperators

    the sequence of MongoDB aggregation operations

    explain

    if true indicates to return the information on the processing of the pipeline

    allowDiskUse

    if true enables writing to temporary files

    bypassDocumentValidation

    if true enables to bypass document validation during the operation

    readConcern

    the read concern

    readPreference

    the read preference for the result

    batchSize

    the batch size (for the aggregation cursor; if None use the default one)

    reader

    the result reader

    cf

    the cursor flattener (by default use the builtin one)

  13. def aggregateWith[T](explain: Boolean = false, allowDiskUse: Boolean = false, bypassDocumentValidation: Boolean = false, readConcern: Option[ReadConcern] = None, readPreference: ReadPreference = ReadPreference.primary, batchSize: Option[Int] = None)(f: (AggregationFramework) ⇒ (PipelineOperator, List[PipelineOperator]))(implicit ec: ExecutionContext, reader: P.Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

    Permalink

    Aggregates the matching documents.

    Aggregates the matching documents.

    T

    The type of the result elements. An implicit Reader[T] typeclass for handling it has to be in the scope.

    explain

    if true indicates to return the information on the processing of the pipeline

    allowDiskUse

    if true enables writing to temporary files

    bypassDocumentValidation

    if true enables to bypass document validation during the operation

    readConcern

    the read concern

    readPreference

    the read preference for the result (default: primary)

    batchSize

    the batch size (for the aggregation cursor; if None use the default one)

    f

    the function to create the aggregation pipeline using the aggregation framework depending on the collection type

    reader

    the result reader

    cf

    the cursor flattener (by default use the builtin one)

  14. def as[C <: Collection](failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): C

    Permalink

    Gets another implementation of this collection.

    Gets another implementation of this collection. An implicit CollectionProducer[C] must be present in the scope, or it will be the default implementation (reactivemongo.api.collections.bson.BSONCollection).

    failoverStrategy

    the failover strategy to override the default one

    Definition Classes
    Collection
  15. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  16. def bulkInsert(documents: Stream[P.Document], ordered: Boolean, writeConcern: WriteConcern = defaultWriteConcern, bulkSize: Int, bulkByteSize: Int)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  17. def bulkInsert(documents: Stream[P.Document], ordered: Boolean, writeConcern: WriteConcern)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  18. def bulkInsert(documents: Stream[P.Document], ordered: Boolean)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  19. def bulkInsert(ordered: Boolean, writeConcern: WriteConcern, bulkSize: Int, bulkByteSize: Int)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  20. def bulkInsert(ordered: Boolean, writeConcern: WriteConcern)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  21. def bulkInsert(ordered: Boolean)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

    Permalink
  22. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  23. def convertToCapped(size: Long, maxDocuments: Option[Int])(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    Converts this collection to a capped one.

    Converts this collection to a capped one.

    size

    the size of the collection (number of bytes)

    maxDocuments

    the maximum number of documents this capped collection can contain

    Definition Classes
    CollectionMetaCommands
  24. def count[H](selector: Option[P.Document] = None, limit: Int = 0, skip: Int = 0, hint: Option[H] = None)(implicit h: (H) ⇒ Hint, ec: ExecutionContext): Future[Int]

    Permalink

    Counts the matching documents.

    Counts the matching documents.

    H

    The type of hint. An implicit H => Hint conversion has to be in the scope.

    selector

    the document selector (default: None to count all)

    limit

    the maximum number of matching documents to count

    skip

    the number of matching documents to skip before counting

    hint

    the index to use (either the index name or the index document)

    See also

    MongoDB documentation

  25. def create(autoIndexId: Boolean = true)(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    Creates this collection.

    Creates this collection.

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

    autoIndexId

    If true should automatically add an index on the _id field. By default, regular collections will have an indexed _id field, in contrast to capped collections. This MongoDB option is deprecated and will be removed in a future release.

    Definition Classes
    CollectionMetaCommands
  26. def createCapped(size: Long, maxDocuments: Option[Int], autoIndexId: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    Creates this collection as a capped one.

    Creates this collection as a capped one.

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

    size

    the size of the collection (number of bytes)

    maxDocuments

    the maximum number of documents this capped collection can contain

    autoIndexId

    If true should automatically add an index on the _id field. By default, regular collections will have an indexed _id field, in contrast to capped collections. This MongoDB option is deprecated and will be removed in a future release.

    Definition Classes
    CollectionMetaCommands
  27. def distinct[T, M[_] <: Iterable[_]](key: String, selector: Option[P.Document] = None, readConcern: ReadConcern = ReadConcern.Local)(implicit reader: P.NarrowValueReader[T], ec: ExecutionContext, cbf: CanBuildFrom[M[_], T, M[T]]): Future[M[T]]

    Permalink

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

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

    T

    the element type of the distinct values

    M

    the container, that must be a scala.collection.Iterable

    key

    the field for which to return distinct values

    selector

    the document selector, that specifies the documents from which to retrieve the distinct values.

    readConcern

    the read concern

    val distinctStates = collection.distinct[String, Set]("state")
  28. def drop(failIfNotFound: Boolean)(implicit ec: ExecutionContext): Future[Boolean]

    Permalink

    Drops this 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.

    Definition Classes
    CollectionMetaCommands
  29. def ensuring(cond: (GenericCollection[P]) ⇒ Boolean, msg: ⇒ Any): GenericCollection[P]

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to Ensuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  30. def ensuring(cond: (GenericCollection[P]) ⇒ Boolean): GenericCollection[P]

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to Ensuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  31. def ensuring(cond: Boolean, msg: ⇒ Any): GenericCollection[P]

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to Ensuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  32. def ensuring(cond: Boolean): GenericCollection[P]

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to Ensuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  33. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  34. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  35. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  36. def find[S, P](selector: S, projection: P)(implicit swriter: P.Writer[S], pwriter: P.Writer[P]): GenericQueryBuilder[pack.type]

    Permalink

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

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

    S

    The type of the selector. An implicit Writer[S] typeclass for handling it has to be in the scope.

    P

    The type of the projection object. An implicit Writer[P] typeclass for handling it has to be in the scope.

    selector

    the document selector

    projection

    the projection document to select only a subset of each matching documents

    swriter

    the writer for the selector

    pwriter

    the writer for the projection

    returns

    A GenericQueryBuilder that you can use to to customize the query. You can obtain a cursor by calling the method reactivemongo.api.Cursor on this query builder.

    See also

    MongoDB documentation

  37. def find[S](selector: S)(implicit swriter: P.Writer[S]): GenericQueryBuilder[pack.type]

    Permalink

    Finds the documents matching the given criteria (selector).

    Finds the documents matching the given criteria (selector).

    S

    The type of the selector. An implicit Writer[S] typeclass for handling it has to be in the scope.

    selector

    the document selector

    swriter

    the writer for the selector

    returns

    A GenericQueryBuilder that you can use to to customize the query. You can obtain a cursor by calling the method reactivemongo.api.Cursor on this query builder.

    See also

    MongoDB documentation

  38. def findAndModify[S](selector: S, modifier: Modify, sort: Option[P.Document] = None, fields: Option[P.Document] = None)(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[FindAndModifyResult]

    Permalink

    Applies a findAndModify operation.

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

    val updateOp = collection.updateModifier(
      BSONDocument("$set" -> BSONDocument("age" -> 35)))
    
    val personBeforeUpdate: Future[Option[Person]] =
      collection.findAndModify(BSONDocument("name" -> "Joline"), updateOp).
      map(_.result[Person])
    
    val removedPerson: Future[Option[Person]] = collection.findAndModify(
      BSONDocument("name" -> "Jack"), collection.removeModifier).
      map(_.result[Person])
    selector

    the document selector

    modifier

    the modify operator to be applied

    sort

    the document indicating the sort criteria (default: None)

    fields

    the projection fields

    swriter

    the writer for the selector

  39. def findAndRemove[S](selector: S, sort: Option[P.Document] = None, fields: Option[P.Document] = None)(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[FindAndModifyResult]

    Permalink

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

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

    val removed: Future[Person] = collection.findAndRemove(
      BSONDocument("name" -> "Foo")).map(_.result[Person])
    S

    The type of the selector. An implicit Writer[S] typeclass for handling it has to be in the scope.

    selector

    the document selector

    sort

    the document indicating the sort criteria

    fields

    the projection fields

    swriter

    the writer for the selector

  40. def findAndUpdate[S, T](selector: S, update: T, fetchNewObject: Boolean = false, upsert: Boolean = false, sort: Option[P.Document] = None, fields: Option[P.Document] = None)(implicit swriter: P.Writer[S], writer: P.Writer[T], ec: ExecutionContext): Future[FindAndModifyResult]

    Permalink

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

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

    val person: Future[BSONDocument] = collection.findAndUpdate(
      BSONDocument("name" -> "James"),
      BSONDocument("$set" -> BSONDocument("age" -> 17)),
      fetchNewObject = true) // on success, return the update document:
                             // { "age": 17 }
    selector

    the document selector

    update

    the update to be applied

    fetchNewObject

    the command result must be the new object instead of the old one.

    upsert

    if true, creates a new document if no document is matching, otherwise if at least one document matches, an update is applied

    sort

    the document indicating the sort criteria (default: None)

    fields

    the projection fields

    swriter

    the writer for the selector

    writer

    writerParam

  41. def formatted(fmtstr: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to StringFormat[GenericCollection[P]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  42. def fullCollectionName: String

    Permalink

    Gets the full qualified name of this collection.

    Gets the full qualified name of this collection.

    Definition Classes
    Collection
  43. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  44. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  45. def indexesManager(implicit ec: ExecutionContext): CollectionIndexesManager

    Permalink

    Returns an index manager for this collection.

    Returns an index manager for this collection.

    Definition Classes
    CollectionMetaCommands
  46. def insert[T](document: T, writeConcern: WriteConcern = defaultWriteConcern)(implicit writer: P.Writer[T], ec: ExecutionContext): Future[WriteResult]

    Permalink

    Inserts a document into the collection and waits for the reactivemongo.api.commands.WriteResult.

    Inserts a document into the collection and waits for the reactivemongo.api.commands.WriteResult.

    T

    The type of the document to insert. An implicit Writer[T] typeclass for handling it has to be in the scope.

    document

    the document to insert

    writeConcern

    the writer concern to be used

    writer

    the writer to create the document to be inserted

    returns

    a future reactivemongo.api.commands.WriteResult that can be used to check whether the insertion was successful

  47. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  48. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  49. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  50. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  51. def readPreference: ReadPreference

    Permalink
  52. def remove[S](selector: S, writeConcern: WriteConcern = defaultWriteConcern, firstMatchOnly: Boolean = false)(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[WriteResult]

    Permalink

    Removes the matching document(s).

    Removes the matching document(s).

    S

    The type of the selector. An implicit Writer[S] typeclass for handling it has to be in the scope.

    selector

    the document selector

    writeConcern

    the writer concern to be used

    firstMatchOnly

    states whether only the first matched documents has to be removed from this collection.

    swriter

    the writer for the selector

    returns

    a future reactivemongo.api.commands.WriteResult that can be used to check whether the removal was successful

  53. lazy val removeModifier: Remove.type

    Permalink

    Returns a removal modifier, to be used with findAndModify.

  54. def rename(to: String, dropExisting: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    Renames this collection.

    Renames this collection.

    to

    the new name of this collection

    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
    CollectionMetaCommands
  55. def runCommand[C <: CollectionCommand](command: C)(implicit writer: P.Writer[ResolvedCollectionCommand[C]]): CursorFetcher[pack.type, Cursor]

    Permalink
  56. def runCommand[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[R]

    Permalink
  57. def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]], rp: ReadPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[A]

    Permalink
  58. def runWithResponse[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[ResponseResult[R]]

    Permalink
  59. def runner: CommandWithPackRunner[pack.type]

    Permalink
  60. def sibling[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): C

    Permalink

    Gets another collection in the current database.

    Gets another collection in the current database. An implicit CollectionProducer[C] must be present in the scope, or it will be the default implementation (reactivemongo.api.collections.bson.BSONCollection).

    name

    the name of another collection

    failoverStrategy

    the failover strategy to override the default one

    Definition Classes
    Collection
  61. def stats(scale: Int)(implicit ec: ExecutionContext): Future[CollStatsResult]

    Permalink

    Returns various information about this collection.

    Returns various information about this collection.

    scale

    the scale factor (for example, to get all the sizes in kilobytes)

    Definition Classes
    CollectionMetaCommands
  62. def stats()(implicit ec: ExecutionContext): Future[CollStatsResult]

    Permalink

    Returns various information about this collection.

    Returns various information about this collection.

    Definition Classes
    CollectionMetaCommands
  63. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  64. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  65. def update[S, T](selector: S, update: T, writeConcern: WriteConcern = defaultWriteConcern, upsert: Boolean = false, multi: Boolean = false)(implicit swriter: P.Writer[S], writer: P.Writer[T], ec: ExecutionContext): Future[UpdateWriteResult]

    Permalink

    Updates one or more documents matching the given selector with the given modifier or update object.

    Updates one or more documents matching the given selector with the given modifier or update object.

    S

    The type of the selector. An implicit Writer[S] typeclass for handling it has to be in the scope.

    T

    The type of the modifier or update object. An implicit Writer[T] typeclass for handling it has to be in the scope.

    selector

    the selector object, for finding the documents to update.

    update

    the modifier object (with special keys like $set) or replacement object.

    writeConcern

    the writer concern to be used

    upsert

    if true, creates a new document if no document is matching, otherwise if at least one document matches, an update is applied (defaults: false)

    multi

    states whether the update may be done on all the matching documents (default: false)

    swriter

    the writer for the selector

    writer

    the writer to create the document

    returns

    a future reactivemongo.api.commands.WriteResult that can be used to check whether the insertion was successful

  66. def updateModifier[U](update: U, fetchNewObject: Boolean = false, upsert: Boolean = false)(implicit updateWriter: P.Writer[U]): Update

    Permalink

    Returns an update modifier, to be used with findAndModify.

    Returns an update modifier, to be used with findAndModify.

    update

    the update to be applied

    fetchNewObject

    the command result must be the new object instead of the old one.

    upsert

    if true, creates a new document if no document is matching, otherwise if at least one document matches, an update is applied

  67. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  68. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  69. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  70. def watchFailure[T](future: ⇒ Future[T]): Future[T]

    Permalink
    Attributes
    protected
  71. def [B](y: B): (GenericCollection[P], B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from GenericCollection[P] to ArrowAssoc[GenericCollection[P]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Deprecated Value Members

  1. def drop()(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    Drops this collection.

    Drops this collection.

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

    Definition Classes
    CollectionMetaCommands
    Annotations
    @deprecated
    Deprecated

    (Since version 0.12.0) Use drop(Boolean)

  2. def emptyCapped()(implicit ec: ExecutionContext): Future[Unit]

    Permalink

    If this collection is capped, removes all the documents it contains.

    If this collection is capped, removes all the documents it contains.

    Deprecated because it became an internal command, unavailable by default.

    Definition Classes
    CollectionMetaCommands
    Annotations
    @deprecated
    Deprecated

    (Since version 0.9) Deprecated because emptyCapped became an internal command, unavailable by default.

  3. def runCommand[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R])(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[R]

    Permalink
    Definition Classes
    GenericCollectionWithCommands
    Annotations
    @deprecated
    Deprecated

    (Since version 0.12-RC5) Use the alternative with ReadPreference

  4. def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]])(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[A]

    Permalink
    Definition Classes
    GenericCollectionWithCommands
    Annotations
    @deprecated
    Deprecated

    (Since version 0.12-RC5) Use the alternative with ReadPreference

  5. def runWithResponse[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R])(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[ResponseResult[R]]

    Permalink
    Definition Classes
    GenericCollectionWithCommands
    Annotations
    @deprecated
    Deprecated

    (Since version 0.12-RC5) Use the alternative with ReadPreference

  6. def sister[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = ...): C

    Permalink

    Gets another collection in the current database.

    Gets another collection in the current database. An implicit CollectionProducer[C] must be present in the scope, or it will be the default implementation (reactivemongo.api.collections.bson.BSONCollection).

    name

    the name of another collection

    failoverStrategy

    the failover strategy to override the default one

    Definition Classes
    Collection
    Annotations
    @deprecated
    Deprecated

    (Since version 0.10) Consider using sibling instead

  7. def uncheckedInsert[T](document: T)(implicit writer: P.Writer[T]): Unit

    Permalink

    Inserts a document into the collection without writeConcern.

    Inserts a document into the collection without writeConcern.

    Please note that you cannot be sure that the document has been effectively written and when (hence the Unit return type).

    T

    the type of the document to insert. An implicit Writer[T] typeclass for handling it has to be in the scope.

    document

    the document to insert.

    Annotations
    @deprecated
    Deprecated

    (Since version 0.12.0) Use insert

  8. def uncheckedRemove[T](query: T, firstMatchOnly: Boolean = false)(implicit writer: P.Writer[T], ec: ExecutionContext): Unit

    Permalink

    Remove the matched document(s) from the collection without writeConcern.

    Remove the matched document(s) from the collection without writeConcern.

    Please note that you cannot be sure that the matched documents have been effectively removed and when (hence the Unit return type).

    T

    the type of the selector of documents to remove. An implicit Writer[T] typeclass for handling it has to be in the scope.

    query

    the selector of documents to remove.

    firstMatchOnly

    states whether only the first matched documents has to be removed from this collection.

    Annotations
    @deprecated
    Deprecated

    (Since version 0.12.0) Use remove

  9. def uncheckedUpdate[S, U](selector: S, update: U, upsert: Boolean = false, multi: Boolean = false)(implicit selectorWriter: P.Writer[S], updateWriter: P.Writer[U]): Unit

    Permalink

    Updates one or more documents matching the given selector with the given modifier or update object.

    Updates one or more documents matching the given selector with the given modifier or update object.

    Please note that you cannot be sure that the matched documents have been effectively updated and when (hence the Unit return type).

    S

    the type of the selector object. An implicit Writer[S] typeclass for handling it has to be in the scope.

    U

    the type of the modifier or update object. An implicit Writer[U] typeclass for handling it has to be in the scope.

    selector

    the selector object, for finding the documents to update.

    update

    the modifier object (with special keys like $set) or replacement object.

    upsert

    states whether the update objet should be inserted if no match found. Defaults to false.

    multi

    states whether the update may be done on all the matching documents.

    Annotations
    @deprecated
    Deprecated

    (Since version 0.12.0) Use update

Inherited from ImplicitCommandHelpers[P]

Inherited from CollectionMetaCommands

Inherited from GenericCollectionWithCommands[P]

Inherited from Collection

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from GenericCollection[P] to any2stringadd[GenericCollection[P]]

Inherited by implicit conversion StringFormat from GenericCollection[P] to StringFormat[GenericCollection[P]]

Inherited by implicit conversion Ensuring from GenericCollection[P] to Ensuring[GenericCollection[P]]

Inherited by implicit conversion ArrowAssoc from GenericCollection[P] to ArrowAssoc[GenericCollection[P]]

Ungrouped