Enables writing to temporary files. A null value indicates that it's unspecified.

Aggregation

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 bypass document level validation flag.

Note:: This only applies when an $out stage is specified.

Aggregation

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 for this operation. A null value means no comment is set.

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()

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 single observable limited to the first result.

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 aggregation.

For MongoDB 5.0+, the aggregate command accepts a "let" option. This option is a document consisting of zero or more fields representing variables that are accessible to the aggregation pipeline. The key is the name of the variable and the value is a constant in the aggregate expression language. Each parameter name is then usable to access the value of the corresponding expression with the "$$" syntax within aggregate expression contexts which may require the use of '$expr' or a pipeline.

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 maximum await execution time on the server for this operation.

Max Time

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

Max Time

Use a specific execution context for future operations

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))

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.

Sets the timeoutMode for the cursor.

Requires the timeout to be set, either in the MongoClientSettings, via MongoDatabase or via MongoCollection

If the timeout is set then:

- For non-tailable cursors, the default value of timeoutMode is TimeoutMode.CURSOR_LIFETIME - For tailable cursors, the default value of timeoutMode is TimeoutMode.ITERATION and its an error to configure it as: TimeoutMode.CURSOR_LIFETIME

Aggregates documents according to the specified aggregation pipeline, which must end with a $out stage.

Aggregation

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.

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.