action
An Action that can be executed on a database.
An Action that can be executed on a database. The Action type allows a separation of execution
logic and resource usage management logic from composition logic. Actions can be composed with
methods such as andThen, andFinally and flatMap. Individual parts of a composite Action
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 Action's effect type, e.g. Effect.Read with Effect.Write. When composing
Actions, the correct combined effect type will be inferred. Effects are used to tie
an Action to a specific back-end type and they can also 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.
The result type when executing the Action 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
Actions it is NoStream.
The context object passed to database actions by the execution engine.
An Action that represents an andThen operation for sequencing in the Action monad.
An Action that represents an asTry operation.
An Action that represents a cleanUp operation for sequencing in the Action monad.
An Action that represents a database operation.
An Action that represents a database operation. Concrete implementations are backend-specific.
A phantom type for annotating database Actions with specific effects (e.g.
A phantom type for annotating database Actions with specific effects (e.g. Write or
Transactional). Effects can be composed through intersection types (e.g.
Write with Transactional. Backends declare all supported types to prevent execution
of unsupported features (e.g. scala.slick.memory.HeapBackend does not support
transactions). Further restrictions (like ensuring that all writes go to a master
database but reads can also be performed by a slave) can be enforced in user-level code.
An Action that represents a failed operation.
An Action that fails.
An Action that represents a flatMap operation for sequencing in the Action monad.
An asynchronous Action that returns the result of a Future.
An Action that attaches a name for logging purposes to another action.
A phantom type used as the streaming result type for Actions that do not support streaming.
A phantom type used as the streaming result type for Actions 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 phantom type used as the streaming result type for Actions that do support streaming.
An ActionContext with extra functionality required for streaming Actions.
An Action 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. DatabaseComponent.DatabaseDef.run supports this kind of action out of the box
through DatabaseComponent.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.
An Action that represents a zip operation for sequencing in the Action monad.
Some utility methods for working with database results in a synchronous or blocking way that can be detrimental to performance when used incorrectly.