BSONQueryBuilder

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (BSONQueryBuilder, 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).

val collection: Collection

def comment(message: String): Self

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

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  comment("Any comment to trace the query")

val commentString: Option[String]

def copy(queryOption: Option[BSONDocument] = queryOption, sortOption: Option[BSONDocument] = sortOption, projectionOption: Option[BSONDocument] = projectionOption, hintOption: Option[BSONDocument] = hintOption, explainFlag: Boolean = explainFlag, snapshotFlag: Boolean = snapshotFlag, commentString: Option[String] = commentString, options: QueryOpts = options, failoverStrategy: FailoverStrategy = failoverStrategy, maxTimeMsOption: Option[Long] = maxTimeMsOption): BSONQueryBuilder

def cursor[T](readPreference: ReadPreference = readPreference, isMongo26WriteOp: Boolean = false)(implicit reader: 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: (BSONQueryBuilder) ⇒ Boolean, msg: ⇒ Any): BSONQueryBuilder

def ensuring(cond: (BSONQueryBuilder) ⇒ Boolean): BSONQueryBuilder

def ensuring(cond: Boolean, msg: ⇒ Any): BSONQueryBuilder

def ensuring(cond: Boolean): BSONQueryBuilder

final def eq(arg0: AnyRef): Boolean

def exhaust: Self

Toggles Exhaust

def explain(flag: Boolean = true): Self

Toggles explain mode.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).explain()

val explainFlag: Boolean

val failoverStrategy: FailoverStrategy

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hint(document: Document): Self

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

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  hint(BSONDocument("hint" -> 1)) // sets the hint

val hintOption: Option[BSONDocument]

final def isInstanceOf[T0]: Boolean

def max(document: Document): Self

Sets the max document.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  max(BSONDocument("field" -> "maxValue"))

def max: Option[Document]

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

def maxScan(max: Double): Self

Sets the maxScan flag.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  maxScan(1.23D)

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.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  maxTimeMs(1000L/* 1s */

val maxTimeMsOption: Option[Long]

def min(document: Document): Self

Sets the min document.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  min(BSONDocument("field" -> "minValue"))

def min: Option[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: 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: 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

val options: QueryOpts

val pack: BSONSerializationPack.type

def projection(p: Document): Self

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

def projection[Pjn](p: Pjn)(implicit writer: 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]]())

val projectionOption: Option[BSONDocument]

val queryOption: Option[BSONDocument]

def readConcern(concern: ReadConcern): Self

Sets the ReadConcern.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  readConcern(reactivemongo.api.ReadConcern.Local)

def readConcern: ReadConcern

The read concern

def requireOne[T](readPreference: ReadPreference)(implicit reader: 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: 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 = true): Self

Sets the returnKey flag.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).returnKey()

def returnKey: Boolean

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

def showRecordId(flag: Boolean = true): Self

Sets the showRecordId flag.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  showRecordId()

def showRecordId: Boolean

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

def singleBatch(flag: Boolean = true): Self

Sets the singleBatch flag.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).
  singleBatch()

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.

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

def foo(coll: BSONCollection) = coll.find(BSONDocument.empty).snapshot()

val snapshotFlag: Boolean

def sort(document: 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]]())

val sortOption: Option[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.

lazy val version: MongoWireVersion

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (BSONQueryBuilder, B)

val self: Any

val self: Any

def filter(predicate: 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: 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: Document): Self

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

def readPreference: ReadPreference

The default ReadPreference

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

def x: BSONQueryBuilder

def x: BSONQueryBuilder