ZQuery

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, may fail with an E, and may succeed with an A. All requests that do not need to be performed sequentially, as expressed by flatMap or combinators derived from it, will automatically be batched, allowing for aggressive data source specific optimizations. Requests will also automatically 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

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def &>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

A symbolic alias for zipParRight.
final def *>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

A symbolic alias for zipRight.
final def <&[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

A symbolic alias for zipParLeft.
final def <&>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

A symbolic alias for zipPar.
final def <*[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

A symbolic alias for zipLeft.
final def <*>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

A symbolic alias for zip.
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def >>=[R1 <: R, E1 >: E, B](f: (A) ⇒ ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

A symbolic alias for flatMap.
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def bimap[E1, B](f: (E) ⇒ E1, g: (A) ⇒ B)(implicit ev: CanFail[E]): ZQuery[R, E1, B]

Returns a query whose failure and success channels have been mapped by the specified pair of functions, f and g.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def either(implicit ev: CanFail[E]): 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.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flatMap[R1 <: R, E1 >: E, B](f: (A) ⇒ ZQuery[R1, E1, B]): 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 batched, though deduplication and caching of requests will still be applied.
final def fold[B](failure: (E) ⇒ B, success: (A) ⇒ B)(implicit ev: CanFail[E]): 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.
final def foldCauseM[R1 <: R, E1, B](failure: (Cause[E]) ⇒ ZQuery[R1, E1, B], success: (A) ⇒ ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

A more powerful version of foldM that allows recovering from any type of failure except interruptions.
final def foldM[R1 <: R, E1, B](failure: (E) ⇒ ZQuery[R1, E1, B], success: (A) ⇒ ZQuery[R1, E1, B])(implicit ev: CanFail[E]): 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.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def map[B](f: (A) ⇒ B): ZQuery[R, E, B]

Maps the specified function over the successful result of this query.
final def mapError[E1](f: (E) ⇒ E1)(implicit ev: CanFail[E]): ZQuery[R, E1, A]

Maps the specified function over the failed result of this query.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def optional: 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.
final def orDie(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZQuery[R, Nothing, A]

Converts this query to one that dies if a query failure occurs.
final def orDieWith(f: (E) ⇒ Throwable)(implicit ev: CanFail[E]): 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.
final def provide(r: Described[R])(implicit ev: NeedsEnv[R]): ZQuery[Any, E, A]

Provides this query with its required environment.
final def provideCustomLayer[E1 >: E, R1 <: Has[_]](layer: Described[ZLayer[zio.ZEnv, E1, R1]])(implicit ev: <:<[zio.ZEnv with R1, R], tagged: zio.Tagged[R1]): ZQuery[zio.ZEnv, E1, A]

Provides the part of the environment that is not part of the ZEnv, leaving a query that only depends on the ZEnv.
final def provideLayer[E1 >: E, R0, R1 <: Has[_]](layer: Described[ZLayer[R0, E1, R1]])(implicit ev1: <:<[R1, R], ev2: NeedsEnv[R]): ZQuery[R0, E1, A]

Provides a layer to this query, which translates it to another level.
final def provideSome[R0](f: Described[(R0) ⇒ R])(implicit ev: NeedsEnv[R]): ZQuery[R0, E, A]

Provides this query with part of its required environment.
final def provideSomeLayer[R0 <: Has[_]]: ProvideSomeLayer[R0, R, E, A]

Splits the environment into two parts, providing one part using the specified layer and leaving the remainder R0.
final val run: ZIO[R, E, A]

Returns an effect that models executing this query.
final def runCache(cache: Cache): ZIO[R, E, A]

Returns an effect that models executing this query with the specified cache.
Returns an effect that models executing this query with the specified cache. This can be useful for deterministically "replaying" a query without executing any new requests.
final def runLog: ZIO[R, E, (Cache, A)]

Returns an effect that models executing this query, returning the query result along with the cache containing a complete log of all requests executed and their results.
Returns an effect that models executing this query, returning the query result along with the cache containing a complete log of all requests executed and their results. This can be useful for logging or analysis of query execution.
final def summarized[R1 <: R, E1 >: E, B, C](summary: ZIO[R1, E1, B])(f: (B, B) ⇒ C): 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.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def timed: ZQuery[R with Clock, E, (Duration, A)]

Returns a new query that executes this one and times the execution.
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def zip[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

Returns a query that models the execution of this query and the specified query sequentially, combining their results into a tuple.
final def zipLeft[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): 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.
final def zipPar[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

Returns a query that models the execution of this query and the specified query in parallel, combining their results into a tuple.
final def zipParLeft[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): 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.
final def zipParRight[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): 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.
final def zipRight[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): 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.
final def zipWith[R1 <: R, E1 >: E, B, C](that: ZQuery[R1, E1, B])(f: (A, B) ⇒ C): 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.
final def zipWithPar[R1 <: R, E1 >: E, B, C](that: ZQuery[R1, E1, B])(f: (A, B) ⇒ C): 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 be batched and deduplication and caching of requests will be applied.

Related Docs: object ZQuery | package zquery

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

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def &>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def *>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def <&[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

final def <&>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

final def <*[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

final def <*>[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

final def ==(arg0: Any): Boolean

final def >>=[R1 <: R, E1 >: E, B](f: (A) ⇒ ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def asInstanceOf[T0]: T0

final def bimap[E1, B](f: (E) ⇒ E1, g: (A) ⇒ B)(implicit ev: CanFail[E]): ZQuery[R, E1, B]

def clone(): AnyRef

final def either(implicit ev: CanFail[E]): ZQuery[R, Nothing, Either[E, A]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def flatMap[R1 <: R, E1 >: E, B](f: (A) ⇒ ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def fold[B](failure: (E) ⇒ B, success: (A) ⇒ B)(implicit ev: CanFail[E]): ZQuery[R, Nothing, B]

final def foldCauseM[R1 <: R, E1, B](failure: (Cause[E]) ⇒ ZQuery[R1, E1, B], success: (A) ⇒ ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def foldM[R1 <: R, E1, B](failure: (E) ⇒ ZQuery[R1, E1, B], success: (A) ⇒ ZQuery[R1, E1, B])(implicit ev: CanFail[E]): ZQuery[R1, E1, B]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def map[B](f: (A) ⇒ B): ZQuery[R, E, B]

final def mapError[E1](f: (E) ⇒ E1)(implicit ev: CanFail[E]): ZQuery[R, E1, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def optional: ZQuery[R, E, Option[A]]

final def orDie(implicit ev1: <:<[E, Throwable], ev2: CanFail[E]): ZQuery[R, Nothing, A]

final def orDieWith(f: (E) ⇒ Throwable)(implicit ev: CanFail[E]): ZQuery[R, Nothing, A]

final def provide(r: Described[R])(implicit ev: NeedsEnv[R]): ZQuery[Any, E, A]

final def provideCustomLayer[E1 >: E, R1 <: Has[_]](layer: Described[ZLayer[zio.ZEnv, E1, R1]])(implicit ev: <:<[zio.ZEnv with R1, R], tagged: zio.Tagged[R1]): ZQuery[zio.ZEnv, E1, A]

final def provideLayer[E1 >: E, R0, R1 <: Has[_]](layer: Described[ZLayer[R0, E1, R1]])(implicit ev1: <:<[R1, R], ev2: NeedsEnv[R]): ZQuery[R0, E1, A]

final def provideSome[R0](f: Described[(R0) ⇒ R])(implicit ev: NeedsEnv[R]): ZQuery[R0, E, A]

final def provideSomeLayer[R0 <: Has[_]]: ProvideSomeLayer[R0, R, E, A]

final val run: ZIO[R, E, A]

final def runCache(cache: Cache): ZIO[R, E, A]

final def runLog: ZIO[R, E, (Cache, A)]

final def summarized[R1 <: R, E1 >: E, B, C](summary: ZIO[R1, E1, B])(f: (B, B) ⇒ C): ZQuery[R1, E1, (C, A)]

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

final def timed: ZQuery[R with Clock, E, (Duration, A)]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

final def zipLeft[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

final def zipPar[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, (A, B)]

final def zipParLeft[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, A]

final def zipParRight[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def zipRight[R1 <: R, E1 >: E, B](that: ZQuery[R1, E1, B]): ZQuery[R1, E1, B]

final def zipWith[R1 <: R, E1 >: E, B, C](that: ZQuery[R1, E1, B])(f: (A, B) ⇒ C): ZQuery[R1, E1, C]

final def zipWithPar[R1 <: R, E1 >: E, B, C](that: ZQuery[R1, E1, B])(f: (A, B) ⇒ C): ZQuery[R1, E1, C]

Inherited from AnyRef

Inherited from Any

Ungrouped