GenericQueryBuilder

abstract def commentString: Option[String]

abstract def explainFlag: Boolean

abstract def failoverStrategy: FailoverStrategy

abstract def hintOption: Option[P.Document]

abstract def maxTimeMsOption: Option[Long]

abstract def options: QueryOpts

abstract val pack: P

abstract def projectionOption: Option[P.Document]

abstract def queryOption: Option[P.Document]

abstract def snapshotFlag: Boolean

abstract def sortOption: Option[P.Document]

abstract def version: MongoWireVersion

abstract def copy(queryOption: Option[P.Document] = queryOption, sortOption: Option[P.Document] = sortOption, projectionOption: Option[P.Document] = projectionOption, hintOption: Option[P.Document] = hintOption, explainFlag: Boolean = explainFlag, snapshotFlag: Boolean = snapshotFlag, commentString: Option[String] = commentString, options: QueryOpts = options, failoverStrategy: FailoverStrategy = failoverStrategy, maxTimeMsOption: Option[Long] = maxTimeMsOption): Self

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (GenericQueryBuilder[P], B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def allowPartialResults: Self

For queries against a sharded collection, returns partial results from the mongos if some shards are unavailable instead of throwing an error.

final def asInstanceOf[T0]: T0

def awaitData: Self

Toggles AwaitData: Block a little while waiting for more data instead of returning immediately if no data.

def batchSize(n: Int): Self

Sets an upper limit on the number of documents to retrieve per batch.

lazy val builder: Builder[pack.type]

def clone(): AnyRef

def collation(collation: Collation): Self

Sets the collation document.

def collation: Option[Collation]

The optional collation to use for the find command (default: None).

def collection: Collection

def comment(message: String): Self

Adds a comment to this query, that may appear in the MongoDB logs.

def cursor[T](readPreference: ReadPreference = readPreference, isMongo26WriteOp: Boolean = false)(implicit reader: P.Reader[T], cp: CursorProducer[T]): ProducedCursor

Returns a Cursor for the result of this query.

import scala.concurrent.{ ExecutionContext, Future }

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

def findAllVisible(coll: BSONCollection)(
  implicit ec: ExecutionContext): Future[List[BSONDocument]] =
  coll.find(BSONDocument("visible" -> true)).
    cursor[BSONDocument]().collect[List](
     maxDocs = 10,
     err = Cursor.FailOnError[List[BSONDocument]]())

def ensuring(cond: (GenericQueryBuilder[P]) ⇒ Boolean, msg: ⇒ Any): GenericQueryBuilder[P]

def ensuring(cond: (GenericQueryBuilder[P]) ⇒ Boolean): GenericQueryBuilder[P]

def ensuring(cond: Boolean, msg: ⇒ Any): GenericQueryBuilder[P]

def ensuring(cond: Boolean): GenericQueryBuilder[P]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exhaust: Self

Toggles Exhaust

def explain(flag: Boolean = true): Self

Toggles explain mode.

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def hint(document: P.Document): Self

Sets the hint document (a document that declares the index MongoDB should use for this query).

final def isInstanceOf[T0]: Boolean

def max(document: P.Document): Self

Sets the max document.

def max: Option[P.Document]

The optional exclusive upper bound for a specific index (default: None).

def maxScan(max: Double): Self

Sets the maxScan flag.

def maxScan: Option[Double]

This option specifies a maximum number of documents or index keys the query plan will scan.

def maxTimeMs(p: Long): Self

Adds maxTimeMs to query

def min(document: P.Document): Self

Sets the min document.

def min: Option[P.Document]

The optional exclusive lower bound for a specific index (default: None).

final def ne(arg0: AnyRef): Boolean

def noCursorTimeout: Self

Toggles NoCursorTimeout: The cursor will not expire automatically

final def notify(): Unit

final def notifyAll(): Unit

def one[T](readPreference: ReadPreference)(implicit reader: P.Reader[T], ec: ExecutionContext): Future[Option[T]]

Sends this query and gets a future Option[T] (alias for reactivemongo.api.Cursor.headOption).

import scala.concurrent.{ ExecutionContext, Future }

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

def findUser(coll: BSONCollection, name: String)(
  implicit ec: ExecutionContext): Future[Option[BSONDocument]] =
  coll.find(BSONDocument("user" -> name)).
    one[BSONDocument](ReadPreference.primaryPreferred)

def one[T](implicit reader: P.Reader[T], ec: ExecutionContext): Future[Option[T]]

Sends this query and gets a future Option[T] (alias for reactivemongo.api.Cursor.headOption) (using the default reactivemongo.api.ReadPreference).

import scala.concurrent.{ ExecutionContext, Future }

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

case class User(name: String, pass: String)

implicit val handler = Macros.reader[User]

def findUser(coll: BSONCollection, name: String)(
  implicit ec: ExecutionContext): Future[Option[User]] =
  coll.find(BSONDocument("user" -> name)).one[User]

def oplogReplay: Self

Toggles OplogReplay

def options(options: QueryOpts): Self

def projection(p: P.Document): Self

Sets the projection specification to determine which fields to include in the returned documents.

def projection[Pjn](p: Pjn)(implicit writer: P.Writer[Pjn]): Self

Sets the projection specification to determine which fields to include in the returned documents.

import scala.concurrent.{ ExecutionContext, Future }

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

def findAllWithProjection(coll: BSONCollection)(
  implicit ec: ExecutionContext): Future[List[BSONDocument]] =
  coll.find(BSONDocument.empty).
    projection(BSONDocument("age" -> 1)). // only consider 'age' field
    cursor[BSONDocument]().
    collect[List](
      maxDocs = 100,
      err = Cursor.FailOnError[List[BSONDocument]]())

def readConcern(concern: ReadConcern): Self

Sets the ReadConcern.

def readConcern: ReadConcern

The read concern

def requireOne[T](readPreference: ReadPreference)(implicit reader: P.Reader[T], ec: ExecutionContext): Future[T]

Sends this query and gets a future T (alias for reactivemongo.api.Cursor.head).

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.ReadPreference
import reactivemongo.api.bson.{ BSONDocument, Macros }
import reactivemongo.api.bson.collection.BSONCollection

case class User(name: String, pass: String)

implicit val handler = Macros.handler[User]

def findUser(coll: BSONCollection, name: String)(
  implicit ec: ExecutionContext): Future[User] =
  coll.find(BSONDocument("user" -> name)).
    requireOne[User](ReadPreference.primaryPreferred)

def requireOne[T](implicit reader: P.Reader[T], ec: ExecutionContext): Future[T]

Sends this query and gets a future T (alias for reactivemongo.api.Cursor.head) (using the default reactivemongo.api.ReadPreference).

import scala.concurrent.{ ExecutionContext, Future }

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

def findUser(coll: BSONCollection, name: String)(
  implicit ec: ExecutionContext): Future[BSONDocument] =
  coll.find(BSONDocument("user" -> name)).requireOne[BSONDocument]

def returnKey(flag: Boolean): Self

Sets the returnKey flag.

def returnKey: Boolean

If this flag is true, returns only the index keys in the resulting documents.

def showRecordId(flag: Boolean): Self

Sets the showRecordId flag.

def showRecordId: Boolean

The flags to determines whether to return the record identifier for each document.

def singleBatch(flag: Boolean): Self

Sets the singleBatch flag.

def singleBatch: Boolean

The flag to determines whether to close the cursor after the first batch (default: false)

def skip(n: Int): Self

Sets the number of documents to skip at the beginning of the results.

def slaveOk: Self

Toggles SlaveOk: The query is might be run on a secondary.

def snapshot(flag: Boolean = true): Self

Toggles snapshot mode.

def sort(document: P.Document): Self

Sets the sort specification for the ordering of the results.

import scala.concurrent.{ ExecutionContext, Future }

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

def findSortedVisible(coll: BSONCollection)(
  implicit ec: ExecutionContext): Future[List[BSONDocument]] =
  coll.find(BSONDocument("visible" -> true)).
    sort(BSONDocument("age" -> 1)). // sort per age
    cursor[BSONDocument]().
    collect[List](
      maxDocs = 100,
      err = Cursor.FailOnError[List[BSONDocument]]())

final def synchronized[T0](arg0: ⇒ T0): T0

def tailable: Self

Toggles TailableCursor: Makes the cursor not to close after all the data is consumed.

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def →[B](y: B): (GenericQueryBuilder[P], B)

val self: Any

val self: Any

def filter(predicate: P.Document): Self

Sets the query predicate; If unspecified, then all documents in the collection will match the predicate.

def filter[Qry](predicate: Qry)(implicit writer: P.Writer[Qry]): Self

Sets the query predicate; If unspecified, then all documents in the collection will match the predicate.

def partial: Self

Toggles Partial: The response can be partial - if a shard is down, no error will be thrown.

def query(selector: P.Document): Self

def query[Qry](selector: Qry)(implicit writer: P.Writer[Qry]): Self

def readPreference: ReadPreference

The default ReadPreference

def updateOptions(update: (QueryOpts) ⇒ QueryOpts): Self

def x: GenericQueryBuilder[P]

def x: GenericQueryBuilder[P]