Packages

final class ZQuery[-R, +E, +A] extends AnyRef

A ZQuery[R, E, A] is a purely functional description of an effectual query that may contain requests from one or more data sources, requires an environment R, and may fail with an E or succeed with an A.

Requests that can be performed in parallel, as expressed by zipWithPar and combinators derived from it, will automatically be batched. Requests that must be performed sequentially, as expressed by zipWith and combinators derived from it, will automatically be pipelined. This allows for aggressive data source specific optimizations. Requests can also be deduplicated and cached.

This allows for writing queries in a high level, compositional style, with confidence that they will automatically be optimized. For example, consider the following query from a user service.

val getAllUserIds: ZQuery[Any, Nothing, List[Int]]         = ???
def getUserNameById(id: Int): ZQuery[Any, Nothing, String] = ???

for {
  userIds   <- getAllUserIds
  userNames <- ZQuery.foreachPar(userIds)(getUserNameById)
} yield userNames

This would normally require N + 1 queries, one for getAllUserIds and one for each call to getUserNameById. In contrast, ZQuery will automatically optimize this to two queries, one for userIds and one for userNames, assuming an implementation of the user service that supports batching.

Based on "There is no Fork: an Abstraction for Efficient, Concurrent, and Concise Data Access" by Simon Marlow, Louis Brandy, Jonathan Coens, and Jon Purdy. http://simonmar.github.io/bib/papers/haxl-icfp14.pdf

Self Type
ZQuery[R, E, A]
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZQuery
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def &>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    A symbolic alias for zipParRight.

  4. def *>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    A symbolic alias for zipRight.

  5. def <&[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    A symbolic alias for zipParLeft.

  6. def <&>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    A symbolic alias for zipPar.

  7. def <*[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    A symbolic alias for zipLeft.

  8. def <*>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    A symbolic alias for zip.

  9. def <~[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    A symbolic alias for zipBatchedLeft.

  10. def <~>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    A symbolic alias for zipBatched.

  11. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  12. def @@[LowerR <: UpperR, UpperR <: R, LowerE >: E, UpperE >: LowerE, LowerA >: A, UpperA >: LowerA](aspect: => QueryAspect[LowerR, UpperR, LowerE, UpperE, LowerA, UpperA])(implicit trace: Trace): ZQuery[UpperR, LowerE, LowerA]

    Syntax for adding aspects.

  13. def absolve[E1 >: E, B](implicit ev: IsSubtypeOfOutput[A, Either[E1, B]], trace: Trace): ZQuery[R, E1, B]

    Returns a query which submerges the error case of Either into the error channel of the query

    Returns a query which submerges the error case of Either into the error channel of the query

    The inverse of ZQuery.either

  14. def as[B](b: => B)(implicit trace: Trace): ZQuery[R, E, B]

    Maps the success value of this query to the specified constant value.

  15. def asExitMaybe: Option[Exit[E, A]]

    Extracts the value of this ZQuery as an exit if the result of the query is known, and it does not contain any side effects.

    Extracts the value of this ZQuery as an exit if the result of the query is known, and it does not contain any side effects.

    This applies to queries that have been constructed via ZQuery.succeedNow and other xNow constructors. The only exception is ZQuery.fromZIONow, which is assumed to contain side effects unless the provided effect was an zio.Exit

  16. def asExitOrElse[E1 >: E, A1 >: A](default: Exit[E1, A1]): Exit[E1, A1]
  17. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  18. def asSomeError(implicit trace: Trace): ZQuery[R, Option[E], A]

    Lifts the error channel into a Some value for composition with other optional queries

  19. def cached(implicit trace: Trace): ZQuery[R, E, A]

    Enables caching for this query.

    Enables caching for this query. Note that caching is enabled by default so this will only be effective to enable caching in part of a larger query in which caching has been disabled.

    See also

    memoize for memoizing the result of a single query

  20. def catchAll[R1 <: R, E2, A1 >: A](h: (E) => ZQuery[R1, E2, A1])(implicit ev: CanFail[E], trace: Trace): ZQuery[R1, E2, A1]

    Recovers from all errors.

  21. def catchAllCause[R1 <: R, E2, A1 >: A](h: (Cause[E]) => ZQuery[R1, E2, A1])(implicit trace: Trace): ZQuery[R1, E2, A1]

    Recovers from all errors with provided Cause.

  22. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
  23. def either(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, Either[E, A]]

    Returns a query whose failure and success have been lifted into an Either.

    Returns a query whose failure and success have been lifted into an Either. The resulting query cannot fail, because the failure case has been exposed as part of the Either success case.

  24. def ensuring[R1 <: R](finalizer: => ZIO[R1, Nothing, Any])(implicit trace: Trace): ZQuery[R1, E, A]

    Ensures that if this query starts executing, the specified query will be executed immediately after this query completes execution, whether by success or failure.

  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  27. def flatMap[R1 <: R, E1 >: E, B](f: (A) => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    Returns a query that models execution of this query, followed by passing its result to the specified function that returns a query.

    Returns a query that models execution of this query, followed by passing its result to the specified function that returns a query. Requests composed with flatMap or combinators derived from it will be executed sequentially and will not be pipelined, though deduplication and caching of requests may still be applied.

  28. def flatten[R1 <: R, E1 >: E, B](implicit ev: IsSubtypeOfOutput[A, ZQuery[R1, E1, B]], trace: Trace): ZQuery[R1, E1, B]

    Returns a query that performs the outer query first, followed by the inner query, yielding the value of the inner query.

    Returns a query that performs the outer query first, followed by the inner query, yielding the value of the inner query.

    This method can be used to "flatten" nested queries.

  29. def fold[B](failure: (E) => B, success: (A) => B)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, B]

    Folds over the failed or successful result of this query to yield a query that does not fail, but succeeds with the value returned by the left or right function passed to fold.

  30. def foldCauseQuery[R1 <: R, E1, B](failure: (Cause[E]) => ZQuery[R1, E1, B], success: (A) => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    A more powerful version of foldQuery that allows recovering from any type of failure except interruptions.

  31. def foldQuery[R1 <: R, E1, B](failure: (E) => ZQuery[R1, E1, B], success: (A) => ZQuery[R1, E1, B])(implicit ev: CanFail[E], trace: Trace): ZQuery[R1, E1, B]

    Recovers from errors by accepting one query to execute for the case of an error, and one query to execute for the case of success.

  32. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  33. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  34. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  35. def left[B, C](implicit ev: IsSubtypeOfOutput[A, Either[B, C]], trace: Trace): ZQuery[R, Either[E, C], B]

    "Zooms in" on the value in the Left side of an Either, moving the possibility that the value is a Right to the error channel.

  36. def map[B](f: (A) => B)(implicit trace: Trace): ZQuery[R, E, B]

    Maps the specified function over the successful result of this query.

  37. def mapBoth[E1, B](f: (E) => E1, g: (A) => B)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, E1, B]

    Returns a query whose failure and success channels have been mapped by the specified pair of functions, f and g.

  38. def mapBothCause[E1, B](f: (Cause[E]) => Cause[E1], g: (A) => B)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, E1, B]

    Returns a query whose failure cause and success channels have been mapped by the specified pair of functions, f and g.

  39. def mapDataSources[R1 <: R](f: => DataSourceAspect[R1])(implicit trace: Trace): ZQuery[R1, E, A]

    Transforms all data sources with the specified data source aspect.

  40. def mapError[E1](f: (E) => E1)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, E1, A]

    Maps the specified function over the failed result of this query.

  41. def mapErrorCause[E2](h: (Cause[E]) => Cause[E2])(implicit trace: Trace): ZQuery[R, E2, A]

    Returns a query with its full cause of failure mapped using the specified function.

    Returns a query with its full cause of failure mapped using the specified function. This can be used to transform errors while preserving the original structure of Cause.

  42. def mapZIO[R1 <: R, E1 >: E, B](f: (A) => ZIO[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    Maps the specified effectual function over the result of this query.

  43. def memoize(implicit trace: Trace): UIO[ZQuery[R, E, A]]

    Returns an effect that, that if evaluated, will return a lazily computed version of this query

    Returns an effect that, that if evaluated, will return a lazily computed version of this query

    This differs from query caching, as caching will only cache the output of a DataSource. memoize will ensure that the query (including non-DataSource backed queries) is computed at-most-once.

    This can beneficial for cases that a query is composed of multiple queries and it's reused multiple times, e.g.,

    case class Foo(x: UQuery[Int], y: UQuery[Int])
val query: UQuery[Int] = ???

// Query will be run exactly once; might not be necessary if `x` or `y` are not used afterwards
query.map(i => Foo(ZQuery.succeed(i +1), ZQuery.succeed(i + 2)))

// Query will be recomputed each time x or y are used
Foo(query.map(_ + 1), query.map(_ + 2))

// Query will be computed / run at-most-once
query.memoize.map(q => Foo(q.map(_ + 1), q.map(_ + 2)))
  44. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  46. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  47. def optional(implicit trace: Trace): ZQuery[R, E, Option[A]]

    Converts this query to one that returns Some if data sources return results for all requests received and None otherwise.

  48. def orDie(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E], trace: Trace): ZQuery[R, Nothing, A]

    Converts this query to one that dies if a query failure occurs.

  49. def orDieWith(f: (E) => Throwable)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, A]

    Converts this query to one that dies if a query failure occurs, using the specified function to map the error to a Throwable.

  50. def provideEnvironment(r: => Described[ZEnvironment[R]])(implicit trace: Trace): ZQuery[Any, E, A]

    Provides this query with its required environment.

  51. def provideLayer[E1 >: E, R0](layer: => Described[ZLayer[R0, E1, R]])(implicit trace: Trace): ZQuery[R0, E1, A]

    Provides a layer to this query, which translates it to another level.

  52. def provideSomeEnvironment[R0](f: => Described[(ZEnvironment[R0]) => ZEnvironment[R]])(implicit trace: Trace): ZQuery[R0, E, A]

    Provides this query with part of its required environment.

  53. def provideSomeLayer[R0]: ProvideSomeLayer[R0, R, E, A]

    Splits the environment into two parts, providing one part using the specified layer and leaving the remainder R0.

  54. def race[R1 <: R, E1 >: E, A1 >: A](that: => ZQuery[R1, E1, A1])(implicit trace: Trace): ZQuery[R1, E1, A1]

    Races this query with the specified query, returning the result of the first to complete successfully and safely interrupting the other.

  55. def refineOrDie[E1](pf: PartialFunction[E, E1])(implicit ev1: IsSubtypeOfError[E, Throwable], ev2: CanFail[E], trace: Trace): ZQuery[R, E1, A]

    Keeps some of the errors, and terminates the query with the rest

  56. def refineOrDieWith[E1](pf: PartialFunction[E, E1])(f: (E) => Throwable)(implicit ev: CanFail[E], trace: Trace): ZQuery[R, E1, A]

    Keeps some of the errors, and terminates the query with the rest, using the specified function to convert the E into a Throwable.

  57. def right[B, C](implicit ev: IsSubtypeOfOutput[A, Either[B, C]], trace: Trace): ZQuery[R, Either[B, E], C]

    "Zooms in" on the value in the Right side of an Either, moving the possibility that the value is a Left to the error channel.

  58. def run(implicit trace: Trace): ZIO[R, E, A]

    Returns an effect that models executing this query.

  59. def runCache(cache: => Cache)(implicit trace: Trace): ZIO[R, E, A]

    Returns an effect that models executing this query with the specified cache.

  60. def runLog(implicit trace: Trace): ZIO[R, E, (Cache, A)]

    Returns an effect that models executing this query, returning the query result along with the cache.

  61. def sandbox(implicit trace: Trace): ZQuery[R, Cause[E], A]

    Expose the full cause of failure of this query

  62. def sandboxWith[R1 <: R, E2, B](f: (ZQuery[R1, Cause[E], A]) => ZQuery[R1, Cause[E2], B])(implicit trace: Trace): ZQuery[R1, E2, B]

    Companion helper to sandbox.

    Companion helper to sandbox. Allows recovery, and partial recovery, from errors and defects alike, as in:

  63. def some[B](implicit ev: IsSubtypeOfOutput[A, Option[B]], trace: Trace): ZQuery[R, Option[E], B]

    Extracts a Some value into the value channel while moving the None into the error channel for easier composition

    Extracts a Some value into the value channel while moving the None into the error channel for easier composition

    Inverse of ZQuery.unoption

  64. def someOrElse[B](default: => B)(implicit ev: <:<[A, Option[B]], trace: Trace): ZQuery[R, E, B]

    Extracts the optional value or succeeds with the given 'default' value.

  65. def someOrElseZIO[B, R1 <: R, E1 >: E](default: ZQuery[R1, E1, B])(implicit ev: <:<[A, Option[B]], trace: Trace): ZQuery[R1, E1, B]

    Extracts the optional value or executes the given 'default' query.

  66. def someOrFail[B, E1 >: E](e: => E1)(implicit ev: IsSubtypeOfOutput[A, Option[B]], trace: Trace): ZQuery[R, E1, B]

    Extracts the optional value or fails with the given error e.

  67. def summarized[R1 <: R, E1 >: E, B, C](summary0: ZIO[R1, E1, B])(f: (B, B) => C)(implicit trace: Trace): ZQuery[R1, E1, (C, A)]

    Summarizes a query by computing some value before and after execution, and then combining the values to produce a summary, together with the result of execution.

  68. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  69. def timed(implicit trace: Trace): ZQuery[R, E, (zio.Duration, A)]

    Returns a new query that executes this one and times the execution.

  70. def timeout(duration: => zio.Duration)(implicit trace: Trace): ZQuery[R, E, Option[A]]

    Returns an effect that will timeout this query, returning None if the timeout elapses before the query was completed.

  71. def timeoutFail[E1 >: E](e: => E1)(duration: => zio.Duration)(implicit trace: Trace): ZQuery[R, E1, A]

    The same as timeout, but instead of producing a None in the event of timeout, it will produce the specified error.

  72. def timeoutFailCause[E1 >: E](cause: => Cause[E1])(duration: => zio.Duration)(implicit trace: Trace): ZQuery[R, E1, A]

    The same as timeout, but instead of producing a None in the event of timeout, it will produce the specified failure.

  73. def timeoutTo[B](b: => B): TimeoutTo[R, E, A, B]

    Returns a query that will timeout this query, returning either the default value if the timeout elapses before the query has completed or the result of applying the function f to the successful result of the query.

  74. def toString(): String
    Definition Classes
    AnyRef → Any
  75. def uncached(implicit trace: Trace): ZQuery[R, E, A]

    Disables caching for this query.

  76. def unleft[E1, B](implicit ev: IsSubtypeOfError[E, Either[E1, B]], trace: Trace): ZQuery[R, E1, Either[A, B]]

    Converts a ZQuery[R, Either[E, B], A] into a ZQuery[R, E, Either[A, B]].

    Converts a ZQuery[R, Either[E, B], A] into a ZQuery[R, E, Either[A, B]]. The inverse of left.

  77. def unoption[E1](implicit ev: IsSubtypeOfError[E, Option[E1]], trace: Trace): ZQuery[R, E1, Option[A]]

    Converts an option on errors into an option on values.

  78. def unrefine[E1 >: E](pf: PartialFunction[Throwable, E1])(implicit trace: Trace): ZQuery[R, E1, A]

    Takes some fiber failures and converts them into errors.

  79. def unrefineTo[E1 >: E](implicit arg0: ClassTag[E1], trace: Trace): ZQuery[R, E1, A]

    Takes some fiber failures and converts them into errors.

  80. def unrefineWith[E1](pf: PartialFunction[Throwable, E1])(f: (E) => E1)(implicit trace: Trace): ZQuery[R, E1, A]

    Takes some fiber failures and converts them into errors, using the specified function to convert the E into an E1.

  81. def unright[E1, B](implicit ev: IsSubtypeOfError[E, Either[B, E1]], trace: Trace): ZQuery[R, E1, Either[B, A]]

    Converts a ZQuery[R, Either[B, E], A] into a ZQuery[R, E, Either[B, A]].

    Converts a ZQuery[R, Either[B, E], A] into a ZQuery[R, E, Either[B, A]]. The inverse of right.

  82. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  83. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  84. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  85. def withParallelism(n: => Int)(implicit trace: Trace): ZQuery[R, E, A]

    Sets the parallelism for this query to the specified maximum number of fibers.

  86. def withParallelismUnbounded(implicit trace: Trace): ZQuery[R, E, A]

    Sets the parallelism for this query to the specified maximum number of fibers.

  87. def zip[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    Returns a query that models the execution of this query and the specified query sequentially, combining their results into a tuple.

  88. def zipBatched[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    Returns a query that models the execution of this query and the specified query, batching requests to data sources and combining their results into a tuple.

  89. def zipBatchedLeft[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    Returns a query that models the execution of this query and the specified query, batching requests to data sources and returning the result of this query.

  90. def zipBatchedRight[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    Returns a query that models the execution of this query and the specified query, batching requests to data sources and returning the result of the specified query.

  91. def zipLeft[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    Returns a query that models the execution of this query and the specified query sequentially, returning the result of this query.

  92. def zipPar[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit zippable: Zippable[A, B], trace: Trace): ZQuery[R1, E1, Out]

    Returns a query that models the execution of this query and the specified query in parallel, combining their results into a tuple.

  93. def zipParLeft[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, A]

    Returns a query that models the execution of this query and the specified query in parallel, returning the result of this query.

  94. def zipParRight[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    Returns a query that models the execution of this query and the specified query in parallel, returning the result of the specified query.

  95. def zipRight[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    Returns a query that models the execution of this query and the specified query sequentially, returning the result of the specified query.

  96. def zipWith[R1 <: R, E1 >: E, B, C](that: => ZQuery[R1, E1, B])(f: (A, B) => C)(implicit trace: Trace): ZQuery[R1, E1, C]

    Returns a query that models the execution of this query and the specified query sequentially, combining their results with the specified function.

    Returns a query that models the execution of this query and the specified query sequentially, combining their results with the specified function. Requests composed with zipWith or combinators derived from it will automatically be pipelined.

  97. def zipWithBatched[R1 <: R, E1 >: E, B, C](that: => ZQuery[R1, E1, B])(f: (A, B) => C)(implicit trace: Trace): ZQuery[R1, E1, C]

    Returns a query that models the execution of this query and the specified query, batching requests to data sources.

  98. def zipWithPar[R1 <: R, E1 >: E, B, C](that: => ZQuery[R1, E1, B])(f: (A, B) => C)(implicit trace: Trace): ZQuery[R1, E1, C]

    Returns a query that models the execution of this query and the specified query in parallel, combining their results with the specified function.

    Returns a query that models the execution of this query and the specified query in parallel, combining their results with the specified function. Requests composed with zipWithPar or combinators derived from it will automatically be batched.

  99. def ~>[R1 <: R, E1 >: E, B](that: => ZQuery[R1, E1, B])(implicit trace: Trace): ZQuery[R1, E1, B]

    A symbolic alias for zipBatchedRight.

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from AnyRef

Inherited from Any

Ungrouped