Safe Haskell | None |
---|---|
Language | Haskell2010 |
This module provides an mtl
-style MonadPersist
typeclass for persistent
,
as well as a PersistT
monad transformer that implements it. If you use this
module, it is recommended that you do not import Database.Persist.Class or
Database.Persist.Sql, since this module defines its own versions of the
things defined in those modules and exports them.
Most notably, the SqlPersistT
transformer defined in this module is distinct
from the SqlPersistT
defined in Database.Persist.Sql.
The former is an alias for the PersistT
type defined in this module, while
the latter is an alias for ReaderT
over a SqlBackend
.
In general, if you are using a SQL database, you should use the helper aliases
MonadSqlPersist
and SqlPersistT
to avoid ambiguous types and complicated
type errors.
- module Database.Persist.Sql
- class Monad m => MonadPersist backend m | m -> backend where
- data PersistT backend m a
- runPersistT :: IsPersistBackend backend => PersistT backend m a -> backend -> m a
- type MonadSqlPersist = MonadPersist SqlBackend
- type SqlPersistT = PersistT SqlBackend
- runSqlPersistT :: MonadBaseControl IO m => SqlPersistT m a -> SqlBackend -> m a
- runSqlPoolPersistT :: MonadBaseControl IO m => SqlPersistT m a -> ConnectionPool -> m a
Documentation
module Database.Persist.Sql
MonadPersist
class Monad m => MonadPersist backend m | m -> backend where Source #
This typeclass is a simple enumeration of the functions available from
Database.Persist.Class, simply parameterized over the monad (rather than
requiring ReaderT
over MonadIO
). This makes it easier to use persistent
in an arbitrary monad transformer stack. Each method corresponds directly to
a function or method defined in Database.Persist.Class or
Database.Persist.Sql. See the documentation for those modules for
information about what each method does.
This typeclass is primarily implemented by the PersistT
monad transformer,
which abstracts away the role of threading a database connection through your
program. If you are using a SQL database, it is recommended that you use the
SqlPersistT
alias and the corresponding runSqlPersistT
function in order
to avoid unnecessarily confusing type errors and to ensure all database
access is performed within a transaction.
This module provides MonadPersist
instances for various commonly-used monad
transformers, but it’s possible that you may want to use a monad transformer
from a different library that does not have an appropriate instance. In this
case, MonadPersist
provides default instances for all monad transformers
using the DefaultSignatures
GHC extension, which allows you to write empty
instance declarations to make any MonadTrans
instance an instance of
MonadPersist
:
instance MonadPersist m => MonadPersist (T m)
get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Maybe record) Source #
insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Key record) Source #
insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m () Source #
insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m [Key record] Source #
insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m () Source #
insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> m () Source #
insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m () Source #
update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m () Source #
updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m record Source #
getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m record Source #
belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2) Source #
belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> m record2 Source #
insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Entity record) Source #
getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> m (Maybe (Entity record)) Source #
deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> m () Source #
insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Maybe (Key record)) Source #
upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> m (Entity record) Source #
getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Entity record)) Source #
insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Either (Entity record) (Key record)) Source #
replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> m (Maybe (Unique record)) Source #
checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Unique record)) Source #
onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Unique record) Source #
selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record)) Source #
count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> m Int Source #
updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> m () Source #
deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> m () Source #
selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Entity record] Source #
selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Key record] Source #
deleteCascade :: DeleteCascade record backend => Key record -> m () Source #
deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> m () Source #
parseMigration :: backend ~ SqlBackend => Migration -> m (Either [Text] CautiousMigration) Source #
parseMigration' :: backend ~ SqlBackend => Migration -> m CautiousMigration Source #
printMigration :: backend ~ SqlBackend => Migration -> m () Source #
showMigration :: backend ~ SqlBackend => Migration -> m [Text] Source #
getMigration :: backend ~ SqlBackend => Migration -> m [Sql] Source #
runMigration :: backend ~ SqlBackend => Migration -> m () Source #
runMigrationSilent :: backend ~ SqlBackend => Migration -> m [Text] Source #
runMigrationUnsafe :: backend ~ SqlBackend => Migration -> m () Source #
rawExecute :: backend ~ SqlBackend => Text -> [PersistValue] -> m () Source #
rawExecuteCount :: backend ~ SqlBackend => Text -> [PersistValue] -> m Int64 Source #
rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> m [a] Source #
transactionSave :: backend ~ SqlBackend => m () Source #
transactionUndo :: backend ~ SqlBackend => m () Source #
get :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Maybe record) Source #
insert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Key record) Source #
insert_ :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m () Source #
insertMany :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m [Key record] Source #
insertMany_ :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m () Source #
insertEntityMany :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> m () Source #
insertKey :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
repsert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
replace :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m () Source #
delete :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m () Source #
update :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m () Source #
updateGet :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m record Source #
getJust :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m record Source #
belongsTo :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2) Source #
belongsToJust :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> m record2 Source #
insertEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Entity record) Source #
getBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> m (Maybe (Entity record)) Source #
deleteBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> m () Source #
insertUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Maybe (Key record)) Source #
upsert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> m (Entity record) Source #
getByValue :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Entity record)) Source #
insertBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Either (Entity record) (Key record)) Source #
replaceUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> m (Maybe (Unique record)) Source #
checkUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Unique record)) Source #
onlyUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Unique record) Source #
selectFirst :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record)) Source #
count :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> m Int Source #
updateWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> m () Source #
deleteWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> m () Source #
selectList :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Entity record] Source #
selectKeysList :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Key record] Source #
deleteCascade :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, DeleteCascade record backend) => Key record -> m () Source #
deleteCascadeWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> m () Source #
parseMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m (Either [Text] CautiousMigration) Source #
parseMigration' :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m CautiousMigration Source #
printMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m () Source #
showMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Text] Source #
getMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Sql] Source #
runMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m () Source #
runMigrationSilent :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Text] Source #
runMigrationUnsafe :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m () Source #
rawExecute :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Text -> [PersistValue] -> m () Source #
rawExecuteCount :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Text -> [PersistValue] -> m Int64 Source #
rawSql :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> m [a] Source #
transactionSave :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => m () Source #
transactionUndo :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => m () Source #
upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> m (Entity record) Source #
upsertBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> m (Entity record) Source #
getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Entity record) Source #
getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m (Maybe (Entity record)) Source #
insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m record Source #
getJustEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Entity record) Source #
getEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m (Maybe (Entity record)) Source #
insertRecord :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m record Source #
MonadPersist backend m => MonadPersist backend (NoLoggingT m) Source # | |
MonadPersist backend m => MonadPersist backend (LoggingT m) Source # | |
(Monoid w, MonadPersist backend m) => MonadPersist backend (WriterT w m) Source # | |
MonadPersist backend m => MonadPersist backend (StateT s m) Source # | |
MonadPersist backend m => MonadPersist backend (ExceptT e m) Source # | |
MonadBaseControl IO m => MonadPersist backend (PersistT backend m) Source # | |
MonadPersist backend m => MonadPersist backend (ReaderT * r m) Source # | |
(Monoid w, MonadPersist backend m) => MonadPersist backend (RWST r w s m) Source # | |
data PersistT backend m a Source #
A concrete monad transformer that implements MonadPersist
. To run it, use
runPersistT
.
If you are using a SQL database, it’s highly recommended that you use the
simpler SqlPersistT
alias, instead.
runPersistT :: IsPersistBackend backend => PersistT backend m a -> backend -> m a Source #
Runs a PersistT
computation with an arbitrary backend.
If you are using a SQL database, it’s highly recommended that you use
runSqlPersistT
, instead, which will run the computation in a transaction.
Specialized to SqlBackend
type MonadSqlPersist = MonadPersist SqlBackend Source #
A simple alias that specializes MonadPersist
to SqlBackend
.
type SqlPersistT = PersistT SqlBackend Source #
A simple alias that specializes PersistT
to SqlBackend
.
runSqlPersistT :: MonadBaseControl IO m => SqlPersistT m a -> SqlBackend -> m a Source #
Runs a SqlPersistT
computation against a SQL database. Unlike
runPersistT
, the computation is run inside a transaction.
runSqlPoolPersistT :: MonadBaseControl IO m => SqlPersistT m a -> ConnectionPool -> m a Source #
Runs a SqlPersistT
computation against a SQL database using a pool of
connections. The computation is run inside a transaction.