The base trait for the context object passed to synchronous database actions by the execution engine.
A DBIOAction that represents a seq
or andThen
operation for sequencing in the DBIOAction
monad.
A DBIOAction that represents a seq
or andThen
operation for sequencing in the DBIOAction
monad. Unlike SequenceAction
it only keeps the last result.
A DBIOAction that represents an asTry
operation.
A DBIOAction that represents a cleanUp
operation for sequencing in the DBIOAction monad.
Simplified type for a DBIOAction without streaming or effect tracking
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
and flatMap
.
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
(using withPinnedSession
) or implicitly (e.g. through a transaction).
The actual implementation base type for all Actions is DBIOAction
. StreamingDBIO
and
DBIO
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).
The result type when executing the DBIOAction and fully materializing the result.
An encoding of the result type for streaming results. If this action is capable of
streaming, it is Streaming[T]
for an element type T
. For non-streaming
DBIOActions it is NoStream
.
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.
A DBIOAction that represents a database operation.
A DBIOAction that represents a database operation. Concrete implementations are backend-specific.
A phantom type for annotating DBIOActions with specific effects (e.g.
A phantom type for annotating DBIOActions with specific effects (e.g. Write
or
Transactional
). 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).
A DBIOAction that represents a failed
operation.
A DBIOAction that fails.
A DBIOAction that represents a flatMap
operation for sequencing in the DBIOAction monad.
An asynchronous DBIOAction that returns the result of a Future.
A DBIOAction that attaches a name for logging purposes to another action.
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.
A DBIOAction that represents a sequence
or operation for sequencing in the DBIOAction monad.
A phantom type used as the streaming result type for DBIOActions that do support streaming.
An ActionContext with extra functionality required for streaming DBIOActions.
Simplified type for a streaming DBIOAction without effect tracking
A DBIOAction that returns a constant value.
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
through BasicBackend.DatabaseDef.runSynchronousDatabaseAction
so that run
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 the andFinally
, andThen
, asTry
,
failed
, withPinnedSession
and zip
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.
The
dbio
package contains the Database I/O Action implementation. See DBIOAction for details.