package dbio
The dbio
package contains the Database I/O Action implementation.
See DBIOAction for details.
- Source
- package.scala
- Alphabetic
- By Inheritance
- dbio
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait ActionContext extends AnyRef
The base trait for the context object passed to synchronous database actions by the execution engine.
- case class AndThenAction[R, +S <: NoStream, -E <: Effect](as: IndexedSeq[DBIOAction[Any, NoStream, E]]) extends DBIOAction[R, S, E] with Product with Serializable
A DBIOAction that represents a
seq
orandThen
operation for sequencing in the DBIOAction monad.A DBIOAction that represents a
seq
orandThen
operation for sequencing in the DBIOAction monad. UnlikeSequenceAction
it only keeps the last result. - case class AsTryAction[+R, -E <: Effect](a: DBIOAction[R, NoStream, E]) extends DBIOAction[Try[R], NoStream, E] with Product with Serializable
A DBIOAction that represents an
asTry
operation. - case class CleanUpAction[+R, +S <: NoStream, -E <: Effect](base: DBIOAction[R, S, E], f: (Option[Throwable]) => DBIOAction[_, NoStream, E], keepFailure: Boolean, executor: ExecutionContext) extends DBIOAction[R, S, E] with Product with Serializable
A DBIOAction that represents a
cleanUp
operation for sequencing in the DBIOAction monad. - type DBIO[+R] = DBIOAction[R, NoStream, All]
Simplified type for a DBIOAction without streaming or effect tracking
- sealed trait DBIOAction[+R, +S <: NoStream, -E <: Effect] extends Dumpable
A Database I/O Action that can be executed on a database.
A Database I/O Action that can be executed on a database. The DBIOAction type allows a separation of execution logic and resource usage management logic from composition logic. DBIOActions can be composed with methods such as
andThen
,andFinally
andflatMap
. Individual parts of a composite DBIOAction are always executed serially on a single database, but possibly in different database sessions, unless the session is pinned either explicitly (usingwithPinnedSession
) or implicitly (e.g. through a transaction).The actual implementation base type for all Actions is
DBIOAction
.StreamingDBIO
andDBIO
are type aliases which discard the effect type (and the streaming result type in the latter case) to make DBIOAction types easier to write when these features are not needed. All primitive DBIOActions and all DBIOActions produced by the standard combinators in Slick have correct Effect types and are streaming (if possible).- R
The result type when executing the DBIOAction and fully materializing the result.
- S
An encoding of the result type for streaming results. If this action is capable of streaming, it is
Streaming[T]
for an element typeT
. For non-streaming DBIOActions it isNoStream
.- E
The DBIOAction's effect type, e.g.
Effect.Read with Effect.Write
. When composing actions, the correct combined effect type will be inferred. Effects can be used in user code, e.g. to automatically direct all read-only Actions to a slave database and write Actions to the master copy.
- trait DatabaseAction[+R, +S <: NoStream, -E <: Effect] extends DBIOAction[R, S, E]
A DBIOAction that represents a database operation.
A DBIOAction that represents a database operation. Concrete implementations are backend-specific.
- trait Effect extends AnyRef
A phantom type for annotating DBIOActions with specific effects (e.g.
A phantom type for annotating DBIOActions with specific effects (e.g.
Write
orTransactional
). Effects can be composed through intersection types (e.g.Write with Transactional
. The standard Slick back-ends do not restrict the evaluation of actions based on effects but they can be used in user-level code (e.g. for ensuring that all writes go to a master database but reads can also be performed by a slave). - case class FailedAction[-E <: Effect](a: DBIOAction[_, NoStream, E]) extends DBIOAction[Throwable, NoStream, E] with Product with Serializable
A DBIOAction that represents a
failed
operation. - case class FailureAction(t: Throwable) extends SynchronousDatabaseAction[Nothing, NoStream, BasicActionContext, BasicStreamingActionContext, Effect] with Product with Serializable
A DBIOAction that fails.
- case class FlatMapAction[+R, +S <: NoStream, P, -E <: Effect](base: DBIOAction[P, NoStream, E], f: (P) => DBIOAction[R, S, E], executor: ExecutionContext) extends DBIOAction[R, S, E] with Product with Serializable
A DBIOAction that represents a
flatMap
operation for sequencing in the DBIOAction monad. - case class FutureAction[+R](f: Future[R]) extends DBIOAction[R, NoStream, Effect] with Product with Serializable
An asynchronous DBIOAction that returns the result of a Future.
- case class NamedAction[+R, +S <: NoStream, -E <: Effect](a: DBIOAction[R, S, E], name: String) extends DBIOAction[R, S, E] with Product with Serializable
A DBIOAction that attaches a name for logging purposes to another action.
- sealed trait NoStream extends AnyRef
A phantom type used as the streaming result type for DBIOActions that do not support streaming.
A phantom type used as the streaming result type for DBIOActions that do not support streaming. Note that this is a supertype of
Streaming
(and it is used in covariant position), so that any streaming action can be used where a non-streaming action is expected. - case class SequenceAction[R, +R2, -E <: Effect](as: IndexedSeq[DBIOAction[R, NoStream, E]])(implicit cbf: Factory[R, R2]) extends DBIOAction[R2, NoStream, E] with Product with Serializable
A DBIOAction that represents a
sequence
or operation for sequencing in the DBIOAction monad. - sealed trait Streaming[+T] extends NoStream
A phantom type used as the streaming result type for DBIOActions that do support streaming.
- trait StreamingActionContext extends ActionContext
An ActionContext with extra functionality required for streaming DBIOActions.
- type StreamingDBIO[+R, +T] = DBIOAction[R, Streaming[T], All]
Simplified type for a streaming DBIOAction without effect tracking
- case class SuccessAction[+R](value: R) extends SynchronousDatabaseAction[R, NoStream, BasicActionContext, BasicStreamingActionContext, Effect] with Product with Serializable
A DBIOAction that returns a constant value.
- trait SynchronousDatabaseAction[+R, +S <: NoStream, -C <: BasicActionContext, -SC <: BasicStreamingActionContext, -E <: Effect] extends DatabaseAction[R, S, E]
A synchronous database action provides a function from an
ActionContext
to the result type.A synchronous database action provides a function from an
ActionContext
to the result type.BasicBackend.DatabaseDef.run
supports this kind of action out of the box throughBasicBackend.DatabaseDef.runSynchronousDatabaseAction
so thatrun
does not need to be extended if all primitive database actions can be expressed in this way. These actions also implement construction-time fusion for theandFinally
,andThen
,asTry
,failed
,withPinnedSession
andzip
operations.The execution engine ensures that an ActionContext is never used concurrently and that all state changes performed by one invocation of a SynchronousDatabaseAction are visible to the next invocation of the same or a different SynchronousDatabaseAction.
Value Members
- val DBIO: DBIOAction.type
- object DBIOAction
- object Effect
- object SynchronousDatabaseAction
edit this text on github
Scala Language-Integrated Connection Kit
This is the API documentation for the Slick database library. It should be used as an additional resource to the user manual.
Further documentation for Slick can be found on the documentation pages.
To the slick package list...