Control.Monad.Persist

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.

Documentation

module Database.Persist.Sql

MonadPersist

class Monad m => MonadPersist backend m | m -> backend where

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)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> m ()

parseMigration :: backend ~ SqlBackend => Migration -> m (Either [Text] CautiousMigration)

parseMigration' :: backend ~ SqlBackend => Migration -> m CautiousMigration

printMigration :: backend ~ SqlBackend => Migration -> m ()

showMigration :: backend ~ SqlBackend => Migration -> m [Text]

getMigration :: backend ~ SqlBackend => Migration -> m [Sql]

runMigration :: backend ~ SqlBackend => Migration -> m ()

runMigrationSilent :: backend ~ SqlBackend => Migration -> m [Text]

runMigrationUnsafe :: backend ~ SqlBackend => Migration -> m ()

rawExecute :: backend ~ SqlBackend => Text -> [PersistValue] -> m ()

rawExecuteCount :: backend ~ SqlBackend => Text -> [PersistValue] -> m Int64

rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> m [a]

transactionSave :: backend ~ SqlBackend => m ()

transactionUndo :: backend ~ SqlBackend => m ()

get :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Maybe record)

insert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Key record)

insert_ :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m ()

insertMany :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m [Key record]

insertMany_ :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> m ()

insertEntityMany :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> m ()

insertKey :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

repsert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

replace :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> m ()

delete :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m ()

update :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m ()

updateGet :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> m record

getJust :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m record

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)

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

insertEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m (Entity record)

getBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> m (Maybe (Entity record))

deleteBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> m ()

insertUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Maybe (Key record))

upsert :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> m (Entity record)

getByValue :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Entity record))

insertBy :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Either (Entity record) (Key record))

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))

checkUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> m (Maybe (Unique record))

onlyUnique :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> m (Unique record)

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))

count :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> m Int

updateWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> m ()

deleteWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> m ()

selectList :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Entity record]

selectKeysList :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> m [Key record]

deleteCascade :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, DeleteCascade record backend) => Key record -> m ()

deleteCascadeWhere :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> m ()

parseMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m (Either [Text] CautiousMigration)

parseMigration' :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m CautiousMigration

printMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m ()

showMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Text]

getMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Sql]

runMigration :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m ()

runMigrationSilent :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m [Text]

runMigrationUnsafe :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Migration -> m ()

rawExecute :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Text -> [PersistValue] -> m ()

rawExecuteCount :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => Text -> [PersistValue] -> m Int64

rawSql :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> m [a]

transactionSave :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => m ()

transactionUndo :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, backend ~ SqlBackend) => m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> m (Entity record)

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)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m record

getJustEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> m (Entity record)

getEntity :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> m (Maybe (Entity record))

insertRecord :: (Monad (t m'), MonadPersist backend m', MonadTrans t, t m' ~ m, PersistStoreWrite backend, PersistRecordBackend record backend) => record -> m record

Instances

MonadPersist backend m => MonadPersist backend (NoLoggingT m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> NoLoggingT m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> NoLoggingT m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> NoLoggingT m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> NoLoggingT m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> NoLoggingT m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> NoLoggingT m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> NoLoggingT m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> NoLoggingT m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> NoLoggingT m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> NoLoggingT m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> NoLoggingT m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> NoLoggingT m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> NoLoggingT m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> NoLoggingT m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> NoLoggingT m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> NoLoggingT m ()

parseMigration :: Migration -> NoLoggingT m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> NoLoggingT m CautiousMigration

printMigration :: Migration -> NoLoggingT m ()

showMigration :: Migration -> NoLoggingT m [Text]

getMigration :: Migration -> NoLoggingT m [Sql]

runMigration :: Migration -> NoLoggingT m ()

runMigrationSilent :: Migration -> NoLoggingT m [Text]

runMigrationUnsafe :: Migration -> NoLoggingT m ()

rawExecute :: Text -> [PersistValue] -> NoLoggingT m ()

rawExecuteCount :: Text -> [PersistValue] -> NoLoggingT m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> NoLoggingT m [a]

transactionSave :: NoLoggingT m ()

transactionUndo :: NoLoggingT m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> NoLoggingT m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m record

MonadPersist backend m => MonadPersist backend (LoggingT m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> LoggingT m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> LoggingT m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> LoggingT m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> LoggingT m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> LoggingT m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> LoggingT m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> LoggingT m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> LoggingT m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> LoggingT m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> LoggingT m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> LoggingT m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> LoggingT m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> LoggingT m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> LoggingT m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> LoggingT m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> LoggingT m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> LoggingT m ()

parseMigration :: Migration -> LoggingT m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> LoggingT m CautiousMigration

printMigration :: Migration -> LoggingT m ()

showMigration :: Migration -> LoggingT m [Text]

getMigration :: Migration -> LoggingT m [Sql]

runMigration :: Migration -> LoggingT m ()

runMigrationSilent :: Migration -> LoggingT m [Text]

runMigrationUnsafe :: Migration -> LoggingT m ()

rawExecute :: Text -> [PersistValue] -> LoggingT m ()

rawExecuteCount :: Text -> [PersistValue] -> LoggingT m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> LoggingT m [a]

transactionSave :: LoggingT m ()

transactionUndo :: LoggingT m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> LoggingT m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m record

(Monoid w, MonadPersist backend m) => MonadPersist backend (WriterT w m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> WriterT w m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> WriterT w m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> WriterT w m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> WriterT w m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> WriterT w m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> WriterT w m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> WriterT w m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> WriterT w m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> WriterT w m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> WriterT w m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> WriterT w m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> WriterT w m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> WriterT w m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> WriterT w m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> WriterT w m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> WriterT w m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> WriterT w m ()

parseMigration :: Migration -> WriterT w m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> WriterT w m CautiousMigration

printMigration :: Migration -> WriterT w m ()

showMigration :: Migration -> WriterT w m [Text]

getMigration :: Migration -> WriterT w m [Sql]

runMigration :: Migration -> WriterT w m ()

runMigrationSilent :: Migration -> WriterT w m [Text]

runMigrationUnsafe :: Migration -> WriterT w m ()

rawExecute :: Text -> [PersistValue] -> WriterT w m ()

rawExecuteCount :: Text -> [PersistValue] -> WriterT w m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> WriterT w m [a]

transactionSave :: WriterT w m ()

transactionUndo :: WriterT w m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> WriterT w m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m record

MonadPersist backend m => MonadPersist backend (StateT s m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> StateT s m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> StateT s m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> StateT s m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> StateT s m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> StateT s m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> StateT s m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> StateT s m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> StateT s m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> StateT s m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> StateT s m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> StateT s m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> StateT s m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> StateT s m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> StateT s m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> StateT s m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> StateT s m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> StateT s m ()

parseMigration :: Migration -> StateT s m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> StateT s m CautiousMigration

printMigration :: Migration -> StateT s m ()

showMigration :: Migration -> StateT s m [Text]

getMigration :: Migration -> StateT s m [Sql]

runMigration :: Migration -> StateT s m ()

runMigrationSilent :: Migration -> StateT s m [Text]

runMigrationUnsafe :: Migration -> StateT s m ()

rawExecute :: Text -> [PersistValue] -> StateT s m ()

rawExecuteCount :: Text -> [PersistValue] -> StateT s m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> StateT s m [a]

transactionSave :: StateT s m ()

transactionUndo :: StateT s m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> StateT s m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> StateT s m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m record

MonadPersist backend m => MonadPersist backend (ExceptT e m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ExceptT e m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ExceptT e m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> ExceptT e m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ExceptT e m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ExceptT e m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ExceptT e m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> ExceptT e m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> ExceptT e m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> ExceptT e m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> ExceptT e m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> ExceptT e m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> ExceptT e m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> ExceptT e m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ExceptT e m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> ExceptT e m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> ExceptT e m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ExceptT e m ()

parseMigration :: Migration -> ExceptT e m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> ExceptT e m CautiousMigration

printMigration :: Migration -> ExceptT e m ()

showMigration :: Migration -> ExceptT e m [Text]

getMigration :: Migration -> ExceptT e m [Sql]

runMigration :: Migration -> ExceptT e m ()

runMigrationSilent :: Migration -> ExceptT e m [Text]

runMigrationUnsafe :: Migration -> ExceptT e m ()

rawExecute :: Text -> [PersistValue] -> ExceptT e m ()

rawExecuteCount :: Text -> [PersistValue] -> ExceptT e m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> ExceptT e m [a]

transactionSave :: ExceptT e m ()

transactionUndo :: ExceptT e m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> ExceptT e m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m record

(MonadIO m, MonadBaseControl IO m) => MonadPersist backend (PersistT backend m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> PersistT backend m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> PersistT backend m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> PersistT backend m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> PersistT backend m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> PersistT backend m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> PersistT backend m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> PersistT backend m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> PersistT backend m ()

parseMigration :: Migration -> PersistT backend m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> PersistT backend m CautiousMigration

printMigration :: Migration -> PersistT backend m ()

showMigration :: Migration -> PersistT backend m [Text]

getMigration :: Migration -> PersistT backend m [Sql]

runMigration :: Migration -> PersistT backend m ()

runMigrationSilent :: Migration -> PersistT backend m [Text]

runMigrationUnsafe :: Migration -> PersistT backend m ()

rawExecute :: Text -> [PersistValue] -> PersistT backend m ()

rawExecuteCount :: Text -> [PersistValue] -> PersistT backend m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> PersistT backend m [a]

transactionSave :: PersistT backend m ()

transactionUndo :: PersistT backend m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> PersistT backend m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m record

MonadPersist backend m => MonadPersist backend (ReaderT * r m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT * r m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ReaderT * r m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ReaderT * r m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> ReaderT * r m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT * r m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT * r m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT * r m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ReaderT * r m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT * r m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT * r m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT * r m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> ReaderT * r m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> ReaderT * r m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> ReaderT * r m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> ReaderT * r m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> ReaderT * r m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> ReaderT * r m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT * r m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> ReaderT * r m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT * r m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> ReaderT * r m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT * r m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT * r m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> ReaderT * r m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ReaderT * r m ()

parseMigration :: Migration -> ReaderT * r m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> ReaderT * r m CautiousMigration

printMigration :: Migration -> ReaderT * r m ()

showMigration :: Migration -> ReaderT * r m [Text]

getMigration :: Migration -> ReaderT * r m [Sql]

runMigration :: Migration -> ReaderT * r m ()

runMigrationSilent :: Migration -> ReaderT * r m [Text]

runMigrationUnsafe :: Migration -> ReaderT * r m ()

rawExecute :: Text -> [PersistValue] -> ReaderT * r m ()

rawExecuteCount :: Text -> [PersistValue] -> ReaderT * r m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> ReaderT * r m [a]

transactionSave :: ReaderT * r m ()

transactionUndo :: ReaderT * r m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> ReaderT * r m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT * r m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ReaderT * r m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT * r m record

(Monoid w, MonadPersist backend m) => MonadPersist backend (RWST r w s m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> RWST r w s m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> RWST r w s m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> RWST r w s m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> RWST r w s m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> RWST r w s m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> RWST r w s m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> RWST r w s m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> RWST r w s m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> RWST r w s m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> RWST r w s m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> RWST r w s m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> RWST r w s m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> RWST r w s m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> RWST r w s m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> RWST r w s m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> RWST r w s m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> RWST r w s m ()

parseMigration :: Migration -> RWST r w s m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> RWST r w s m CautiousMigration

printMigration :: Migration -> RWST r w s m ()

showMigration :: Migration -> RWST r w s m [Text]

getMigration :: Migration -> RWST r w s m [Sql]

runMigration :: Migration -> RWST r w s m ()

runMigrationSilent :: Migration -> RWST r w s m [Text]

runMigrationUnsafe :: Migration -> RWST r w s m ()

rawExecute :: Text -> [PersistValue] -> RWST r w s m ()

rawExecuteCount :: Text -> [PersistValue] -> RWST r w s m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> RWST r w s m [a]

transactionSave :: RWST r w s m ()

transactionUndo :: RWST r w s m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> RWST r w s m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m record

data PersistT backend m a

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.

Instances

MonadBaseControl b m => MonadBaseControl b (PersistT backend m)

Associated Types

type StM (PersistT backend m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (PersistT backend m) b -> b a) -> PersistT backend m a

restoreM :: StM (PersistT backend m) a -> PersistT backend m a

MonadBase b m => MonadBase b (PersistT backend m)

Methods

liftBase :: b α -> PersistT backend m α

MonadError e m => MonadError e (PersistT backend m)

Methods

throwError :: e -> PersistT backend m a

catchError :: PersistT backend m a -> (e -> PersistT backend m a) -> PersistT backend m a

MonadReader r m => MonadReader r (PersistT backend m)

Methods

ask :: PersistT backend m r

local :: (r -> r) -> PersistT backend m a -> PersistT backend m a

reader :: (r -> a) -> PersistT backend m a

MonadState s m => MonadState s (PersistT backend m)

Methods

get :: PersistT backend m s

put :: s -> PersistT backend m ()

state :: (s -> (a, s)) -> PersistT backend m a

MonadWriter w m => MonadWriter w (PersistT backend m)

Methods

writer :: (a, w) -> PersistT backend m a

tell :: w -> PersistT backend m ()

listen :: PersistT backend m a -> PersistT backend m (a, w)

pass :: PersistT backend m (a, w -> w) -> PersistT backend m a

(MonadIO m, MonadBaseControl IO m) => MonadPersist backend (PersistT backend m)

Methods

get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe record)

insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Key record)

insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m ()

insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m [Key record]

insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m ()

insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> PersistT backend m ()

insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m ()

delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m ()

update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m ()

updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m record

getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m record

belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> PersistT backend m (Maybe record2)

belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> PersistT backend m record2

insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Entity record)

getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m (Maybe (Entity record))

deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m ()

insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Key record))

upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> PersistT backend m (Entity record)

getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Entity record))

insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Either (Entity record) (Key record))

replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> PersistT backend m (Maybe (Unique record))

checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Unique record))

onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Unique record)

selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m (Maybe (Entity record))

count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m Int

updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> PersistT backend m ()

deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m ()

selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Entity record]

selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Key record]

deleteCascade :: DeleteCascade record backend => Key record -> PersistT backend m ()

deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> PersistT backend m ()

parseMigration :: Migration -> PersistT backend m (Either [Text] CautiousMigration)

parseMigration' :: Migration -> PersistT backend m CautiousMigration

printMigration :: Migration -> PersistT backend m ()

showMigration :: Migration -> PersistT backend m [Text]

getMigration :: Migration -> PersistT backend m [Sql]

runMigration :: Migration -> PersistT backend m ()

runMigrationSilent :: Migration -> PersistT backend m [Text]

runMigrationUnsafe :: Migration -> PersistT backend m ()

rawExecute :: Text -> [PersistValue] -> PersistT backend m ()

rawExecuteCount :: Text -> [PersistValue] -> PersistT backend m Int64

rawSql :: ((* ~ backend) SqlBackend, RawSql a) => Text -> [PersistValue] -> PersistT backend m [a]

transactionSave :: PersistT backend m ()

transactionUndo :: PersistT backend m ()

upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> PersistT backend m (Entity record)

getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Entity record)

getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe (Entity record))

insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m record

MonadTrans (PersistT backend)

Methods

lift :: Monad m => m a -> PersistT backend m a

MonadTransControl (PersistT backend)

Associated Types

type StT (PersistT backend :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (PersistT backend) -> m a) -> PersistT backend m a

restoreT :: Monad m => m (StT (PersistT backend) a) -> PersistT backend m a

Monad m => Monad (PersistT backend m)

Methods

(>>=) :: PersistT backend m a -> (a -> PersistT backend m b) -> PersistT backend m b

(>>) :: PersistT backend m a -> PersistT backend m b -> PersistT backend m b

return :: a -> PersistT backend m a

fail :: String -> PersistT backend m a

Functor m => Functor (PersistT backend m)

Methods

fmap :: (a -> b) -> PersistT backend m a -> PersistT backend m b

(<$) :: a -> PersistT backend m b -> PersistT backend m a

Applicative m => Applicative (PersistT backend m)

Methods

pure :: a -> PersistT backend m a

(<*>) :: PersistT backend m (a -> b) -> PersistT backend m a -> PersistT backend m b

(*>) :: PersistT backend m a -> PersistT backend m b -> PersistT backend m b

(<*) :: PersistT backend m a -> PersistT backend m b -> PersistT backend m a

MonadIO m => MonadIO (PersistT backend m)

Methods

liftIO :: IO a -> PersistT backend m a

MonadLogger m => MonadLogger (PersistT backend m)

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> PersistT backend m ()

MonadLoggerIO m => MonadLoggerIO (PersistT backend m)

Methods

askLoggerIO :: PersistT backend m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

type StT (PersistT backend) a

type StT (PersistT backend) a = StT (ReaderT * SqlBackend) a

type StM (PersistT backend m) a

type StM (PersistT backend m) a = ComposeSt (PersistT backend) m a

runPersistT :: IsPersistBackend backend => PersistT backend m a -> backend -> m a

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

A simple alias that specializes MonadPersist to SqlBackend.

type SqlPersistT = PersistT SqlBackend

A simple alias that specializes PersistT to SqlBackend.

runSqlPersistT :: (MonadIO m, MonadBaseControl IO m) => SqlPersistT m a -> SqlBackend -> m a

Runs a SqlPersistT computation against a SQL database. Unlike runPersistT, the computation is run inside a transaction.