Enables writing to temporary files on the server. When set to true, the server can write temporary data to disk while executing the find operation.

This option is sent only if the caller explicitly provides a value. The default is to not send a value. For servers < 3.2, this option is ignored and not sent as allowDiskUse does not exist in the OP_QUERY wire protocol.

Applies the side-effecting function to the final result of this Observable and, returns a new Observable with the result of this Observable.

This method allows one to enforce that the callbacks are executed in a specified order.

Note that if one of the chained andThen callbacks throws an exception, that exception is not propagated to the subsequent andThen callbacks. Instead, the subsequent andThen callbacks are given the original value of this Observable.

The following example prints out 10:

Observable(1 to 10) andThen {
 case r => sys.error("runtime exception")
} andThen {
 case Success(x) => print(x)
 case Failure(t) => print("Failure")
}

Sets the number of documents to return per batch.

Sets the collation options

Builds a new Observable by applying a partial function to all elements.

Example:

val justStrings = Observable(Iterable("this", 1, 2, "that")).collect{ case s: String => s }

Collects all the values of the Observable into a list and returns a new Observable with that list.

Example:

val listOfNumbers = Observable(1 to 100).collect()

Sets the comment for this operation. A null value means no comment is set.

Sets the comment to the query. A null value means no comment is set.

Convert this observable so that it emits a single Unit to Observer.onNext before calling Observer.onComplete.

If the underlying observable errors then that is propagated to the Observer. This method is especially useful for chaining Observable[Void] in for comprehensions.

Sets the cursor type.

Explain the execution plan for this operation with the given verbosity level

Explain the execution plan for this operation with the server's default verbosity level

Creates a new Observable which returns the results of this Observable, if there is an error, it will then fallback to returning the results of the alternative "that" Observable.

If both Observables fail, the resulting Observable holds the throwable object of the first Observable.

Example:

val fallBackObservable = Observable(1 to 100) fallbackTo Observable(200 to 300)

Ensuring results from a Single Observer

fallbackTo can potentially emit results from either Observer. This often isn't desirable, so to ensure only a single Observable issues results combine with the collect[S]()* method eg:

val results = Observable(1 to 100).collect() fallbackTo Observable(200 to 300).collect()

Sets the query filter to apply to the query.

Filter

Creates a new Observable by filtering the value of the current Observable with a predicate.

If the current Observable fails, then the resulting Observable also fails.

Example:

val oddValues = Observable(1 to 100) filter { _ % 2 == 1 }

Helper to return a Observable limited to just the first result the query.

**Note:** Sets limit in the background so only returns 1.

Creates a new Observable by applying a function to each emitted result of the Observable. If the Observable calls errors then then the new Observable will also contain this exception.

As each emitted item passed to onNext returns an Observable, we tightly control the requests to the parent Observable. The requested amount is then passed to the child Observable and only when that is completed does the parent become available for requesting more data.

Example:

def f = Observable(1 to 10)
def g = Observable(100 to 100)
val h = for {
  x: Int <- f // returns Observable(1 to 10)
  y: Int <- g // returns Observable(100 to 100)
} yield x + y

is translated to:

f flatMap { (x: Int) => g map { (y: Int) => x + y } }

Creates a new Observable that contains the single result of the applied accumulator function.

The first item emitted by the Observable is passed to the supplied accumulator function alongside the initial value, then all other emitted items are passed along with the previous result of the accumulator function.

Example:

val countingObservable = Observable(1 to 100) foldLeft(0)((v, i) => v + 1)

Applies a function applied to each emitted result.

Automatically requests all results

Returns the head of the Observable in a scala.concurrent.Future.

Returns the head option of the Observable in a scala.concurrent.Future.

Sets the hint for which index to use. A null value means no hint is set.

Sets the hint for which index to use. A null value means no hint is set.

Add top-level variables to the operation. A null value means no variables are set.

Allows for improved command readability by separating the variables from the query text.

Sets the limit to apply.

Limit

Creates a new Observable by applying a function to each emitted result of the Observable. If the Observable calls errors then then the new Observable will also contain this exception.

Example:

def f = Observable(1 to 10)
def g = Observable(100 to 100)
val h = for {
  x: Int <- f // returns Observable(1 to 10)
  y: Int <- g // returns Observable(100 to 100)
} yield x + y

is translated to:

f flatMap { (x: Int) => g map { (y: Int) => x + y } }

Sets the exclusive upper bound for a specific index. A null value means no max is set.

The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. This only applies to a TAILABLE_AWAIT cursor. When the cursor is not a TAILABLE_AWAIT cursor, this option is ignored.

On servers >= 3.2, this option will be specified on the getMore command as "maxTimeMS". The default is no value: no "maxTimeMS" is sent to the server with the getMore command.

On servers < 3.2, this option is ignored, and indicates that the driver should respect the server's default value

A zero value will be ignored.

Max Time

Sets the maximum execution time on the server for this operation.

Max Time

Sets the minimum inclusive lower bound for a specific index. A null value means no max is set.

The server normally times out idle cursors after an inactivity period (10 minutes) to prevent excess memory use. Set this option to prevent that.

Use a specific execution context for future operations

Users should not set this under normal circumstances.

Get partial results from a sharded cluster if one or more shards are unreachable (instead of throwing an error).

Sets a document describing the fields to return for all matching documents.

Projection

Creates a new Observable that will handle any matching throwable that this Observable might contain. If there is no match, or if this Observable contains a valid result then the new Observable will contain the same.

Example:

mongoExceptionObservable recover { case e: MongoException => 0 } // final result: 0
mongoExceptionObservable recover { case e: NotFoundException => 0 } // result: exception

Creates a new Observable that will handle any matching throwable that this Observable might contain by assigning it a value of another Observable.

If there is no match, or if this Observable contains a valid result then the new Observable will contain the same result.

Example:

successfulObservable recoverWith { case e: ArithmeticException => observableB } // result: successfulObservable
mongoExceptionObservable recoverWith { case t: Throwable => observableB } // result: observableB

Ensuring results from a Single Observer

recoverWith can potentially emit results from either Observer. This often isn't desirable, so to ensure only a single Observable issues results combine with the collect[S]()* method eg:

val results = Observable(1 to 100)
  .collect()
  .recoverWith({ case t: Throwable => Observable(200 to 300).collect() })
  .subscribe((i: Seq[Int]) => print(results))

Sets the returnKey. If true the find operation will return only the index keys in the resulting documents.

Sets the showRecordId. Set to true to add a field $recordId to the returned documents.

Sets the number of documents to skip.

Skip

Sets the sort criteria to apply to the query.

Sort

Request Observable to start streaming data.

This is a "factory method" and can be called multiple times, each time starting a new Subscription. Each Subscription will work for only a single Observer.

If the Observable rejects the subscription attempt or otherwise fails it will signal the error via Observer.onError.

Subscribes to the Observable and requests Long.MaxValue.

Uses the default or overridden onNext, onError, onComplete partial functions.

Subscribes to the Observable and requests Long.MaxValue.

Subscribes to the Observable and requests Long.MaxValue.

Subscribes to the Observable and requests Long.MaxValue.

Handles the automatic boxing of a Java Observable so it conforms to the interface.

Creates a new Observable by applying the resultFunction function to each emitted result. If there is an error and onError is called the errorFunction function is applied to the failed result.

Used by for-comprehensions.

Zips the values of this and that Observable, and creates a new Observable holding the tuple of their results.

If this Observable fails, the resulting Observable is failed with the throwable stored in this. Otherwise, if that Observable fails, the resulting Observable is failed with the throwable stored in that.

It will only emit as many items as the number of items emitted by the source Observable that emits the fewest items.