trait GenericCollection[P <: SerializationPack with Singleton] extends Collection with GenericCollectionWithCommands[P] with CollectionMetaCommands with ImplicitCommandHelpers[P] with InsertOps[P] with UpdateOps[P] with DeleteOps[P] with CountOp[P] with DistinctOp[P] with GenericCollectionWithDistinctOps[P] with FindAndModifyOps[P] with ChangeStreamOps[P] with Aggregator[P] with GenericCollectionMetaCommands[P] with GenericCollectionWithQueryBuilder[P] with HintFactory[P]
A Collection that provides default methods using a SerializationPack
.
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]
- Alphabetic
- By Inheritance
- GenericCollection
- HintFactory
- GenericCollectionWithQueryBuilder
- GenericCollectionMetaCommands
- Aggregator
- ChangeStreamOps
- FindAndModifyOps
- GenericCollectionWithDistinctOps
- DistinctOp
- DistinctOpCompat
- CountOp
- DeleteOps
- UpdateOps
- InsertOps
- ImplicitCommandHelpers
- CollectionMetaCommands
- GenericCollectionWithCommands
- Collection
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Type Members
- sealed trait WatchBuilder[T] extends AnyRef
A builder for the
watch
collection helper, which allows to consume the collection's ChangeStream.A builder for the
watch
collection helper, which allows to consume the collection's ChangeStream.- Definition Classes
- ChangeStreamOps
- sealed trait DeleteBuilder extends AnyRef
Builder for delete operations.
Builder for delete operations.
- Definition Classes
- DeleteOps
- type AggregationFramework = AggregationFramework.type
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.
- final class Aggregator[T, AC[_] <: Cursor[_]] extends AnyRef
- Definition Classes
- Aggregator
- final class AggregatorContext[T] extends AnyRef
- Definition Classes
- Aggregator
- See also
reactivemongo.api.commands.AggregationFramework.PipelineOperator
- final class CollectionQueryBuilder extends GenericQueryBuilder[pack.type]
- Attributes
- protected
- Definition Classes
- GenericCollectionWithQueryBuilder
- case class DistinctResult extends Product with Serializable
- Attributes
- protected
- Definition Classes
- DistinctOp
- type PipelineOperator = commands.AggregationFramework.PipelineOperator
Alias for reactivemongo.api.commands.AggregationFramework.PipelineOperator
- sealed trait InsertBuilder extends AnyRef
Builder for insert operations.
Builder for insert operations.
- Definition Classes
- InsertOps
- sealed trait UpdateBuilder extends AnyRef
Builder for update operations.
Builder for update operations.
- Definition Classes
- UpdateOps
- trait ImplicitlyDocumentProducer extends AnyRef
- Definition Classes
- ImplicitCommandHelpers
Abstract Value Members
- abstract val BatchCommands: BatchCommands[pack.type]
- Attributes
- protected
- abstract def db: DB
The database which this collection belongs to.
The database which this collection belongs to.
- Definition Classes
- Collection
- abstract def name: String
The name of the collection.
The name of the collection.
- Definition Classes
- Collection
- abstract val pack: P
- Definition Classes
- GenericCollection → ImplicitCommandHelpers → GenericCollectionWithCommands
- abstract def withReadPreference(pref: ReadPreference): GenericCollection[P]
Returns a new reference to the same collection, with the given read preference.
- abstract def failoverStrategy: FailoverStrategy
The default failover strategy for the methods of this collection.
The default failover strategy for the methods of this collection.
- Definition Classes
- Collection
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Internal: will be made private
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toany2stringadd[GenericCollection[P]] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (GenericCollection[P], B)
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toArrowAssoc[GenericCollection[P]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def MissingMetadata(): ConnectionNotInitialized
- Attributes
- protected
- Annotations
- @inline()
- 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) => commands.AggregationFramework.Pipeline)(implicit reader: P.Reader[T], cp: CursorProducer[T]): ProducedCursor
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
- lazy val aggregationFramework: AggregationFramework
- def aggregatorContext[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: ReadConcern, readPreference: ReadPreference, writeConcern: commands.WriteConcern, batchSize: Option[Int], cursorOptions: CursorOptions, maxTime: Option[FiniteDuration], hint: Option[Hint[pack.type]], comment: Option[String], collation: Option[Collation])(implicit reader: P.Reader[T]): AggregatorContext[T]
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]( Group(BSONString(f"$$state"))( "totalPop" -> SumField("population")), List( Match(BSONDocument("totalPop" -> BSONDocument(f"$$gte" -> 10000000L)))) ).prepared.cursor.collect[List]( maxDocs = 3, err = Cursor.FailOnError[List[BSONDocument]]() ) }
- 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
- writeConcern
the writer concern to be used
- batchSize
the batch size (for the aggregation cursor; if
None
use the default one)- cursorOptions
the options for the result cursor
- maxTime
the time limit for processing operations on a cursor (
maxTimeMS
)- hint
the index to use (either the index name or the index document)
- comment
the comment to annotation the aggregation command
- collation
the collation
- reader
the result reader
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def convertToCapped(size: Long, maxDocuments: Option[Int])(implicit ec: ExecutionContext): Future[Unit]
Converts this collection to a capped one.
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))
- size
the size of the collection (number of bytes)
- maxDocuments
the maximum number of documents this capped collection can contain
- Definition Classes
- CollectionMetaCommands
- def count(selector: Option[P.Document], limit: Option[Int], skip: Int, hint: Option[Hint[pack.type]], readConcern: ReadConcern, readPreference: ReadPreference)(implicit ec: ExecutionContext): Future[Long]
Counts the matching documents.
Counts the matching documents.
- selector
the document selector
- 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
hint(..)
)- readConcern
the read concern
- readPreference
the read preference for the result
- See also
- def count(selector: Option[P.Document], limit: Option[Int], skip: Int, hint: Option[Hint[pack.type]], readConcern: ReadConcern)(implicit ec: ExecutionContext): Future[Long]
Counts the matching documents.
Counts the matching documents.
- selector
the document selector
- 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
hint(..)
)- readConcern
the read concern
- See also
- def countDocuments(query: Option[P.Document], limit: Option[Int], skip: Int, hint: Option[Hint[pack.type]], readConcern: ReadConcern, readPreference: ReadPreference)(implicit ec: ExecutionContext): Future[Long]
- Attributes
- protected
- Definition Classes
- CountOp
- def create(failsIfExists: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]
Creates this collection.
Creates this collection.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.CollectionMetaCommands def createIfNotExists(coll: CollectionMetaCommands)( implicit ec: ExecutionContext): Future[Unit] = coll.create(failsIfExists = true)
- failsIfExists
if true fails if the collection already exists (default: false)
- Definition Classes
- CollectionMetaCommands
- def create()(implicit ec: ExecutionContext): Future[Unit]
Creates this collection.
Creates this collection.
The returned future will be completed, with an error if this collection already exists.
import scala.concurrent.ExecutionContext import reactivemongo.api.CollectionMetaCommands import reactivemongo.api.commands.CommandError def createColl( coll: CollectionMetaCommands)(implicit ec: ExecutionContext) = coll.create().recover { case CommandError.Code(48) => // NamespaceExists println(s"Collection \${coll} already exists") }
- Definition Classes
- CollectionMetaCommands
- def createCapped(size: Long, maxDocuments: Option[Int], autoIndexId: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]
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.
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))
- 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
- See also
- def createView(name: String, operator: PipelineOperator, pipeline: Seq[PipelineOperator], collation: Option[Collation] = None)(implicit ec: ExecutionContext): Future[Unit]
Creates a view on this collection, using an aggregation pipeline.
Creates a view on this collection, using an aggregation pipeline.
- name
the name of the view to be created
- operator
the first (required) operator for the aggregation pipeline
- pipeline
the other pipeline operators
- collation
the view collation
- Definition Classes
- GenericCollectionMetaCommands
- Since
MongoDB 3.4
import scala.concurrent.ExecutionContext import reactivemongo.api.bson.{ BSONDocument, BSONString } import reactivemongo.api.bson.collection.BSONCollection def foo(coll: BSONCollection)(implicit ec: ExecutionContext) = { import coll.aggregationFramework import aggregationFramework.{ Group, Match, SumField } // See http://docs.mongodb.org/manual/tutorial/aggregation-zip-code-data-set/#return-states-with-populations-above-10-million // Create 'myview' coll.createView( name = "myview", operator = Group(BSONString(f"$$state"))( "totalPop" -> SumField("population")), pipeline = Seq(Match( BSONDocument("totalPop" -> BSONDocument(f"$$gte" -> 10000000L))))) // Then the view can be resolved as any collection // (but won't be writeable) val view: BSONCollection = coll.db("myview") }
- def defaultCursorBatchSize: Int
- Attributes
- protected
- Annotations
- @inline()
- def delete(ordered: Boolean = true, writeConcern: commands.WriteConcern = writeConcern): DeleteBuilder
Prepares a delete builder.
Prepares a delete builder.
- ordered
the ordered behaviour
- writeConcern
the writer concern to be used
import scala.concurrent.ExecutionContext import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def foo(coll: BSONCollection, query: BSONDocument)( implicit ec: ExecutionContext) = coll.delete(true).one(query)
- def delete: DeleteBuilder
Prepares an unordered 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)
- def distinct[T, M[_] <: Iterable[_]](key: String, selector: Option[P.Document], readConcern: ReadConcern, collation: Option[Collation])(implicit reader: P.NarrowValueReader[T], ec: ExecutionContext, cbf: Factory[T, M[T]]): Future[M[T]]
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
- collation
the collation
import scala.concurrent.ExecutionContext import reactivemongo.api.ReadConcern import reactivemongo.api.bson.collection.BSONCollection def distinctStates(coll: BSONCollection)(implicit ec: ExecutionContext) = coll.distinct[String, Set]("state", None, ReadConcern.Local, None)
- Definition Classes
- GenericCollectionWithDistinctOps
- def distinctDocuments[T, M[_] <: Iterable[_]](key: String, query: Option[P.Document], readConcern: ReadConcern, collation: Option[Collation], builder: Builder[T, M[T]])(implicit reader: P.NarrowValueReader[T], ec: ExecutionContext): Future[M[T]]
- Attributes
- protected
- Definition Classes
- DistinctOp
- final def distinctDocuments[T, M[_] <: Iterable[_]](key: String, query: Option[P.Document], readConcern: ReadConcern, collation: Option[Collation])(implicit reader: P.NarrowValueReader[T], ec: ExecutionContext, cbf: Factory[T, M[T]]): Future[M[T]]
- Attributes
- protected
- Definition Classes
- DistinctOpCompat
- def drop(failIfNotFound: Boolean)(implicit ec: ExecutionContext): Future[Boolean]
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.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.CollectionMetaCommands def dropIfNotFound(coll: CollectionMetaCommands)( implicit ec: ExecutionContext): Future[Boolean] = coll.drop(failIfNotFound = true)
- failIfNotFound
the flag to request whether it should fail
- Definition Classes
- CollectionMetaCommands
- Annotations
- @silent(".*DropCollectionResult.*")
- def ensuring(cond: (GenericCollection[P]) => Boolean, msg: => Any): GenericCollection[P]
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toEnsuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (GenericCollection[P]) => Boolean): GenericCollection[P]
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toEnsuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): GenericCollection[P]
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toEnsuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): GenericCollection[P]
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toEnsuring[GenericCollection[P]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def find[S, J](selector: S, projection: Option[J] = Option.empty)(implicit swriter: P.Writer[S], pwriter: P.Writer[J]): GenericQueryBuilder[pack.type]
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.- 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
- def findAndModify[S](selector: S, modifier: Modify, sort: Option[P.Document], fields: Option[P.Document], bypassDocumentValidation: Boolean, writeConcern: commands.WriteConcern, maxTime: Option[FiniteDuration], collation: Option[Collation], arrayFilters: Seq[P.Document])(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[Result[pack.type]]
Applies a findAndModify operation.
Applies a findAndModify operation. See
findAndUpdate
andfindAndRemove
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]) }
- selector
the document selector
- modifier
the modify operator to be applied
- sort
the document indicating the sort criteria (default:
None
)- fields
the projection fields
- writeConcern
the writer concern to be used
- maxTime
the time limit for processing operations on a cursor (
maxTimeMS
)- collation
the collation
- arrayFilters
an array of filter documents that determines which array elements to modify for an update operation on an array field
- swriter
the writer for the selector
- def findAndRemove[S](selector: S, sort: Option[P.Document], fields: Option[P.Document], writeConcern: commands.WriteConcern, maxTime: Option[FiniteDuration], collation: Option[Collation], arrayFilters: Seq[P.Document])(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[Result[pack.type]]
Finds some matching document, and removes it (using
findAndModify
).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])
- 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
- writeConcern
the writer concern to be used
- maxTime
the time limit for processing operations on a cursor (
maxTimeMS
)- collation
the collation
- arrayFilters
an array of filter documents that determines which array elements to modify for an update operation on an array field
- swriter
the writer for the selector
- def findAndUpdate[S, T](selector: S, update: T, fetchNewObject: Boolean, upsert: Boolean, sort: Option[P.Document], fields: Option[P.Document], bypassDocumentValidation: Boolean, writeConcern: commands.WriteConcern, maxTime: Option[FiniteDuration], collation: Option[Collation], arrayFilters: Seq[P.Document])(implicit swriter: P.Writer[S], writer: P.Writer[T], ec: ExecutionContext): Future[Result[pack.type]]
Finds some matching document, and updates it (using
findAndModify
).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 }
- 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
- writeConcern
the writer concern to be used
- maxTime
the time limit for processing operations on a cursor (
maxTimeMS
)- collation
the collation
- arrayFilters
an array of filter documents that determines which array elements to modify for an update operation on an array field
- swriter
the writer for the selector
- writer
the writer to create the document
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toStringFormat[GenericCollection[P]] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hint(specification: P.Document): Hint[pack.type]
Returns a hint for the given index
specification
document.Returns a hint for the given index
specification
document.- specification
the index specification document
- Definition Classes
- HintFactory
- def hint(name: String): Hint[pack.type]
Returns a hint for the given index
name
.Returns a hint for the given index
name
.- name
the index name
- Definition Classes
- HintFactory
- def indexesManager(implicit ec: ExecutionContext): Aux[Pack]
Returns an index manager for this collection.
Returns an index manager for this collection.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.CollectionMetaCommands def listIndexes(coll: CollectionMetaCommands)( implicit ec: ExecutionContext): Future[List[String]] = coll.indexesManager.list().map(_.flatMap { idx => idx.name.toList })
- Definition Classes
- CollectionMetaCommands
- def insert(ordered: Boolean, writeConcern: commands.WriteConcern, bypassDocumentValidation: Boolean): InsertBuilder
Returns a builder for insert operations.
Returns a builder for insert operations.
- ordered
the ordered behaviour
- writeConcern
the writer concern to be used
- bypassDocumentValidation
the flag to bypass document validation during the operation
import scala.concurrent.ExecutionContext import reactivemongo.api.WriteConcern import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def withDefaultWriteConcern(coll: BSONCollection, query: BSONDocument)( implicit ec: ExecutionContext) = coll.insert(true, WriteConcern.Journaled, true).one(query)
- def insert(ordered: Boolean, writeConcern: commands.WriteConcern): InsertBuilder
Returns a builder for insert operations.
Returns a builder for insert operations.
- ordered
the ordered behaviour
- writeConcern
the writer concern to be used
import scala.concurrent.ExecutionContext import reactivemongo.api.WriteConcern import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def withDefaultWriteConcern(coll: BSONCollection, query: BSONDocument)( implicit ec: ExecutionContext) = coll.insert(true, WriteConcern.Journaled).one(query)
- def insert(ordered: Boolean): InsertBuilder
Returns a builder for insert operations.
Returns a builder for insert operations. Uses the default write concern.
- ordered
the ordered behaviour
import scala.concurrent.ExecutionContext import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def one(coll: BSONCollection, singleDoc: BSONDocument)( implicit ec: ExecutionContext) = coll.insert(ordered = true).one(singleDoc) def many(coll: BSONCollection, multiInserts: Iterable[BSONDocument])( implicit ec: ExecutionContext) = coll.insert(ordered = true).many(multiInserts)
- def insert: InsertBuilder
Returns an unordered builder for insert operations.
Returns an unordered builder for insert operations. Uses the default write concern.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def readConcern: ReadConcern
The default read concern
The default read concern
- Attributes
- protected
- Annotations
- @inline()
- def readPreference: ReadPreference
The default read preference
The default read preference
- Annotations
- @inline()
- def runCommand[C <: CollectionCommand](command: C)(implicit writer: P.Writer[ResolvedCollectionCommand[C]]): CursorFetcher[pack.type, Cursor]
- Definition Classes
- GenericCollectionWithCommands
- def runCommand[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference = self.readPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[R]
- Definition Classes
- GenericCollectionWithCommands
- def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]], rp: ReadPreference = self.readPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[A]
- Definition Classes
- GenericCollectionWithCommands
- def runWithResponse[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference = self.readPreference)(implicit writer: P.Writer[ResolvedCollectionCommand[C]], reader: P.Reader[R], ec: ExecutionContext): Future[ResponseResult[R]]
- Definition Classes
- GenericCollectionWithCommands
- def runner: CommandWithPackRunner[pack.type]
- Definition Classes
- GenericCollectionWithCommands
- def stats(scale: Int)(implicit ec: ExecutionContext): Future[CollStatsResult]
Returns various information about this collection.
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)
- scale
the scale factor (for example, to get all the sizes in kilobytes)
- Definition Classes
- CollectionMetaCommands
- def stats()(implicit ec: ExecutionContext): Future[CollStatsResult]
Returns various information about this collection.
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)
- Definition Classes
- CollectionMetaCommands
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- GenericCollection → AnyRef → Any
- implicit lazy val unitBoxReader: P.Reader[UnitBox.type]
- Attributes
- protected
- def update(ordered: Boolean, writeConcern: commands.WriteConcern, bypassDocumentValidation: Boolean): UpdateBuilder
Returns an update builder.
Returns an update builder.
import scala.concurrent.ExecutionContext import reactivemongo.api.commands.WriteConcern import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def withDefaultWriteConcern( coll: BSONCollection, query: BSONDocument, update: BSONDocument, wc: WriteConcern )(implicit ec: ExecutionContext) = coll.update( ordered = false, writeConcern = wc, bypassDocumentValidation = true ).one(query, update)
- ordered
the ordered behaviour
- writeConcern
the writer concern to be used
- bypassDocumentValidation
the flag to bypass document validation during the operation
- def update(ordered: Boolean, writeConcern: commands.WriteConcern): UpdateBuilder
Returns an update builder.
Returns an update builder.
import scala.concurrent.ExecutionContext import reactivemongo.api.commands.WriteConcern import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def withDefaultWriteConcern( coll: BSONCollection, query: BSONDocument, update: BSONDocument, wc: WriteConcern )(implicit ec: ExecutionContext) = coll.update(ordered = false, writeConcern = wc).one(query, update)
- ordered
the ordered behaviour
- writeConcern
the writer concern to be used
- def update(ordered: Boolean): UpdateBuilder
Returns an update builder.
Returns an update builder.
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) }
- ordered
the ordered behaviour
- def update: UpdateBuilder
Returns an unordered update builder.
Returns an unordered update builder.
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) }
- def updateModifier[U](update: U, fetchNewObject: Boolean = false, upsert: Boolean = false)(implicit updateWriter: P.Writer[U]): Update
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
- lazy val version: MongoWireVersion
Upper MongoDB version (used for version checks)
Upper MongoDB version (used for version checks)
- Attributes
- protected
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def watch[T](resumeAfter: Option[P.Value] = None, startAtOperationTime: Option[P.Value] = None, pipeline: List[PipelineOperator] = Nil, maxAwaitTimeMS: Option[Long] = None, fullDocumentStrategy: Option[FullDocumentStrategy] = None)(implicit reader: P.Reader[T]): WatchBuilder[T]
Prepares a builder for watching the change stream of this collection.
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 scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.Cursor import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def events(coll: BSONCollection)( implicit ec: ExecutionContext): Cursor[BSONDocument] = coll.watch[BSONDocument]().cursor
- T
the type into which Change Events are deserialized
- resumeAfter
The id of the last known Change Event, if any. The stream will resume just after that event.
- startAtOperationTime
The operation time before which all Change Events are known. Must be in the time range of the oplog. (since MongoDB 4.0)
- pipeline
The sequence of aggregation stages to apply on events in the stream (see MongoDB documentation for a list of valid stages for a change stream).
- maxAwaitTimeMS
The maximum amount of time in milliseconds the server waits for new data changes before returning an empty batch. In practice, this parameter controls the duration of the long-polling behavior of the cursor.
- fullDocumentStrategy
if set to UpdateLookup, every update change event will be joined with the current version of the relevant document.
- reader
the reader of the resulting change events
- Definition Classes
- ChangeStreamOps
- Since
MongoDB 3.6
- def watchFailure[T](future: => Future[T]): Future[T]
- Attributes
- protected
- def writeConcern: commands.WriteConcern
The default write concern
The default write concern
- Attributes
- protected
- Annotations
- @inline()
- def writePreference: ReadPreference
The read preference for the write operations (primary)
The read preference for the write operations (primary)
- Attributes
- protected
- Annotations
- @inline()
- object UpdateCommand extends UpdateCommand[pack.type]
- Definition Classes
- UpdateOps
- Annotations
- @silent(".*UpdateCommand\\ in\\ package\\ commands\\ is\\ deprecated.*")
- object ImplicitlyDocumentProducer
- Definition Classes
- ImplicitCommandHelpers
Deprecated Value Members
- object DeleteCommand extends DeleteCommand[pack.type]
- Definition Classes
- DeleteOps
- Annotations
- @deprecated
- Deprecated
(Since version 0.19.0) Internal: will be made private
- implicit def PackIdentityReader: P.Reader[P.Document]
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Internal: will be made private
- implicit def PackIdentityWriter: P.Writer[P.Document]
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Internal: will be made private
- def aggregateWith1[T](explain: Boolean = false, allowDiskUse: Boolean = false, bypassDocumentValidation: Boolean = false, readConcern: Option[ReadConcern] = None, readPreference: ReadPreference = ReadPreference.primary, batchSize: Option[Int] = None)(f: (AggregationFramework) => commands.AggregationFramework.Pipeline)(implicit ec: ExecutionContext, reader: P.Reader[T], cf: CursorFlattener[Cursor], cp: CursorProducer[T]): ProducedCursor
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)
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Use aggregateWith
- def aggregatorContext[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator] = Nil, explain: Boolean = false, allowDiskUse: Boolean = false, bypassDocumentValidation: Boolean = false, readConcern: Option[ReadConcern] = None, readPreference: ReadPreference = ReadPreference.primary, writeConcern: commands.WriteConcern = this.writeConcern, batchSize: Option[Int] = None, cursorOptions: CursorOptions = CursorOptions.empty, maxTimeMS: Option[Long] = None)(implicit reader: P.Reader[T]): AggregatorContext[T]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.19.8) Use aggregator context with comment
- def aggregatorContext[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern], readPreference: ReadPreference, batchSize: Option[Int])(implicit reader: P.Reader[T]): AggregatorContext[T]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.17.0) Use aggregator context with optional writeConcern
- def as[C <: Collection](failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = BSONCollectionProducer): C
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
- Annotations
- @deprecated
- Deprecated
(Since version 0.13.0) Resolve the collection from DB
- def count[H](selector: Option[P.Document] = None, limit: Int = 0, skip: Int = 0, hint: Option[H] = None)(implicit h: (H) => commands.CountCommand.Hint, ec: ExecutionContext): Future[Int]
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)
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Use
count
withreadConcern
parameter- See also
- def drop()(implicit ec: ExecutionContext): Future[Unit]
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)
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated @deprecated
- Deprecated
(Since version ) see corresponding Javadoc for more information.
- def find[S, J](selector: S, projection: J)(implicit swriter: P.Writer[S], pwriter: P.Writer[J]): GenericQueryBuilder[pack.type]
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.- 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.
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Use
find
with optionalprojection
- See also
- def find[S](selector: S)(implicit swriter: P.Writer[S]): GenericQueryBuilder[pack.type]
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.
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.0) Use
find
with optionalprojection
- See also
- 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]
- Annotations
- @deprecated
- Deprecated
(Since version 0.14.0) Use other
findAndModify
- def findAndRemove[S](selector: S, sort: Option[P.Document] = None, fields: Option[P.Document] = None)(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[FindAndModifyResult]
- Annotations
- @deprecated
- Deprecated
(Since version 0.18.0) Use the other
findAndRemove
- 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]
- Annotations
- @deprecated
- Deprecated
(Since version 0.18.0) Use other
findAndUpdate
- final def fullCollectionName: String
Gets the full qualified name of this collection.
Gets the full qualified name of this collection.
- Definition Classes
- Collection
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.17.0) Internal: will be made private
- def insert[T](document: T, writeConcern: commands.WriteConcern = writeConcern)(implicit writer: P.Writer[T], ec: ExecutionContext): Future[WriteResult]
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
import scala.concurrent.ExecutionContext import reactivemongo.api.bson.BSONDocument import reactivemongo.api.bson.collection.BSONCollection def withDefaultWriteConcern(coll: BSONCollection, myDoc: BSONDocument)( implicit ec: ExecutionContext) = coll.insert(myDoc)
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.1) Use
.insert(ordered = false).one(..)
- def remove[S](selector: S, writeConcern: commands.WriteConcern = writeConcern, firstMatchOnly: Boolean = false)(implicit swriter: P.Writer[S], ec: ExecutionContext): Future[WriteResult]
- S
The type of the selector. An implicit
Writer[S]
typeclass for handling it has to be in the scope.- writeConcern
the writer concern to be used
- swriter
the writer for the selector
- returns
a future reactivemongo.api.commands.WriteResult that can be used to check whether the removal was successful
- Annotations
- @deprecated
- Deprecated
(Since version 0.13.1) Use delete().one(selector, limit)
- lazy val removeModifier: Remove
Returns a removal modifier, to be used with
findAndModify
.Returns a removal modifier, to be used with
findAndModify
.- Annotations
- @deprecated @transient()
- Deprecated
(Since version 0.16.0) Internal: will be made private
- def rename(to: String, dropExisting: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]
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
- Annotations
- @deprecated
- Deprecated
(Since version 0.12.4) Use
reactivemongo.api.DBMetaCommands.renameCollection on the admin database instead.
- def sibling[C <: Collection](name: String, failoverStrategy: FailoverStrategy = failoverStrategy)(implicit producer: CollectionProducer[C] = BSONCollectionProducer): C
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.19.4) Use
DB.collection(name)
- def update[S, T](selector: S, update: T, writeConcern: commands.WriteConcern = writeConcern, upsert: Boolean = false, multi: Boolean = false)(implicit swriter: P.Writer[S], writer: P.Writer[T], ec: ExecutionContext): Future[UpdateWriteResult]
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
- Annotations
- @deprecated
- Deprecated
(Since version 0.16.1) Use
.update(ordered = false).one(..)
- def →[B](y: B): (GenericCollection[P], B)
- Implicit
- This member is added by an implicit conversion from GenericCollection[P] toArrowAssoc[GenericCollection[P]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.