Safe Haskell	None
Language	Haskell2010

Control.Monad.Persist

Contents

MonadPersist
Specialized to SqlBackend

Description

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.

Synopsis

runSqlConn :: (MonadUnliftIO m, IsSqlBackend backend) => ReaderT backend m a -> backend -> m a
runSqlPool :: (MonadUnliftIO m, IsSqlBackend backend) => ReaderT backend m a -> Pool backend -> m a
class RawSql a
type Sql = Text
type CautiousMigration = [(Bool, Sql)]
type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT SqlBackend IO)) ()
type ConnectionPool = Pool SqlBackend
data SqlBackend
class (PersistStoreWrite backend, PersistEntity record, BaseBackend backend ~ PersistEntityBackend record) => DeleteCascade record backend
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend
class (PersistCore backend, PersistStoreRead backend) => PersistUniqueRead backend
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend
class HasPersistBackend backend => IsPersistBackend backend
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend
data family Key record :: *
data family Unique record :: *
data Update record
data SelectOpt record
data Filter record
data Entity record = Entity {
- entityKey :: Key record
- entityVal :: record
}
data PersistValue
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

runSqlConn :: (MonadUnliftIO m, IsSqlBackend backend) => ReaderT backend m a -> backend -> m a #

runSqlPool :: (MonadUnliftIO m, IsSqlBackend backend) => ReaderT backend m a -> Pool backend -> m a #

Get a connection from the pool, run the given action, and then return the connection to the pool.

Note: This function previously timed out after 2 seconds, but this behavior was buggy and caused more problems than it solved. Since version 2.1.2, it performs no timeout checks.

class RawSql a #

Class for data types that may be retrived from a rawSql query.

Minimal complete definition

rawSqlCols, rawSqlColCountReason, rawSqlProcessRow

Instances

RawSql a => RawSql (Maybe a)	Since: persistent-1.0.1
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Maybe a -> (Int, [Text]) # rawSqlColCountReason :: Maybe a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Maybe a) #
PersistField a => RawSql (Single a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Single a -> (Int, [Text]) # rawSqlColCountReason :: Single a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Single a) #
(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Key a -> (Int, [Text]) # rawSqlColCountReason :: Key a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Key a) #
(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Entity record -> (Int, [Text]) # rawSqlColCountReason :: Entity record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record) #
(RawSql a, RawSql b) => RawSql (a, b)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b) -> (Int, [Text]) # rawSqlColCountReason :: (a, b) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b) #
(RawSql a, RawSql b, RawSql c) => RawSql (a, b, c)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c) #
(RawSql a, RawSql b, RawSql c, RawSql d) => RawSql (a, b, c, d)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c, d) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e) => RawSql (a, b, c, d, e)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c, d, e) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f) => RawSql (a, b, c, d, e, f)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c, d, e, f) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g) => RawSql (a, b, c, d, e, f, g)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c, d, e, f, g) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h) => RawSql (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> (a, b, c, d, e, f, g, h) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h) #

type Sql = Text #

type CautiousMigration = [(Bool, Sql)] #

type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT SqlBackend IO)) () #

type ConnectionPool = Pool SqlBackend #

data SqlBackend #

Instances

HasPersistBackend SqlBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlBackend :: * # Methods persistBackend :: SqlBackend -> BaseBackend SqlBackend #
IsPersistBackend SqlBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend #
type BaseBackend SqlBackend
Instance details Defined in Database.Persist.Sql.Types.Internal type BaseBackend SqlBackend = SqlBackend
data BackendKey SqlBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore data BackendKey SqlBackend = SqlBackendKey { unSqlBackendKey :: Int64 }

class (PersistStoreWrite backend, PersistEntity record, BaseBackend backend ~ PersistEntityBackend record) => DeleteCascade record backend #

For combinations of backends and entities that support cascade-deletion. “Cascade-deletion” means that entries that depend on other entries to be deleted will be deleted as well.

Minimal complete definition

deleteCascade

class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend #

Backends supporting conditional read operations.

Minimal complete definition

selectSourceRes, selectKeysRes, count

class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend #

Backends supporting conditional write operations

Minimal complete definition

updateWhere, deleteWhere

class (PersistCore backend, PersistStoreRead backend) => PersistUniqueRead backend #

Queries against Unique keys (other than the id Key).

Please read the general Persistent documentation to learn how to create Unique keys.

Using this with an Entity without a Unique key leads to undefined behavior. A few of these functions require a single Unique, so using an Entity with multiple Uniques is also undefined. In these cases persistent's goal is to throw an exception as soon as possible, but persistent is still transitioning to that.

SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on a field to have a uniqueness constraint.

Minimal complete definition

getBy

class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend #

Some functions in this module (insertUnique, insertBy, and replaceUnique) first query the unique indexes to check for conflicts. You could instead optimistically attempt to perform the operation (e.g. replace instead of replaceUnique). However,

there is some fragility to trying to catch the correct exception and determing the column of failure;
an exception will automatically abort the current SQL transaction.

Minimal complete definition

deleteBy

class HasPersistBackend backend => IsPersistBackend backend #

Class which witnesses that backend is essentially the same as BaseBackend backend. That is, they're isomorphic and backend is just some wrapper over BaseBackend backend.

Minimal complete definition

mkPersistBackend

Instances

IsPersistBackend SqlBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend #
IsPersistBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend #
IsPersistBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend #

type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend) #

A convenient alias for common type signatures

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend #

Minimal complete definition

get

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend #

Minimal complete definition

insert, insertKey, repsert, replace, delete, update

data family Key record :: * #

By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.

Instances

(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Key a -> (Int, [Text]) # rawSqlColCountReason :: Key a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Key a) #

data family Unique record :: * #

Unique keys besides the Key.

data Update record #

Updating a database entity.

Persistent users use combinators to create these.

data SelectOpt record #

Query options.

Persistent users use these directly.

data Filter record #

Filters which are available for select, updateWhere and deleteWhere. Each filter constructor specifies the field being filtered on, the type of comparison applied (equals, not equals, etc) and the argument for the comparison.

Persistent users use combinators to create these.

data Entity record #

Datatype that represents an entity, with both its Key and its Haskell record representation.

When using a SQL-based backend (such as SQLite or PostgreSQL), an Entity may take any number of columns depending on how many fields it has. In order to reconstruct your entity on the Haskell side, persistent needs all of your entity columns and in the right order. Note that you don't need to worry about this when using persistent's API since everything is handled correctly behind the scenes.

However, if you want to issue a raw SQL command that returns an Entity, then you have to be careful with the column order. While you could use SELECT Entity.* WHERE ... and that would work most of the time, there are times when the order of the columns on your database is different from the order that persistent expects (for example, if you add a new field in the middle of you entity definition and then use the migration code -- persistent will expect the column to be in the middle, but your DBMS will put it as the last column). So, instead of using a query like the one above, you may use rawSql (from the Database.Persist.GenericSql module) with its /entity selection placeholder/ (a double question mark ??). Using rawSql the query above must be written as SELECT ?? WHERE ... Then rawSql will replace ?? with the list of all columns that we need from your entity in the right order. If your query returns two entities (i.e. (Entity backend a, Entity backend b)), then you must you use SELECT ??, ?? WHERE ..., and so on.

Constructors

Entity
Fields entityKey :: Key record entityVal :: record

Instances

(Eq (Key record), Eq record) => Eq (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods (==) :: Entity record -> Entity record -> Bool # (/=) :: Entity record -> Entity record -> Bool #
(Ord (Key record), Ord record) => Ord (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods compare :: Entity record -> Entity record -> Ordering # (<) :: Entity record -> Entity record -> Bool # (<=) :: Entity record -> Entity record -> Bool # (>) :: Entity record -> Entity record -> Bool # (>=) :: Entity record -> Entity record -> Bool # max :: Entity record -> Entity record -> Entity record # min :: Entity record -> Entity record -> Entity record #
(Read (Key record), Read record) => Read (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods readsPrec :: Int -> ReadS (Entity record) # readList :: ReadS [Entity record] # readPrec :: ReadPrec (Entity record) # readListPrec :: ReadPrec [Entity record] #
(Show (Key record), Show record) => Show (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods showsPrec :: Int -> Entity record -> ShowS # show :: Entity record -> String # showList :: [Entity record] -> ShowS #
(Generic (Key record), Generic record) => Generic (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Associated Types type Rep (Entity record) :: * -> * # Methods from :: Entity record -> Rep (Entity record) x # to :: Rep (Entity record) x -> Entity record #
(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (DBName -> Text) -> Entity record -> (Int, [Text]) # rawSqlColCountReason :: Entity record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record) #
(PersistField record, PersistEntity record) => PersistFieldSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Entity record) -> SqlType #
(PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods toPersistValue :: Entity record -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Entity record) #
type Rep (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity type Rep (Entity record) = D1 (MetaData "Entity" "Database.Persist.Class.PersistEntity" "persistent-2.8.2-DrAqzafQ1lD2MuVTORsW1e" False) (C1 (MetaCons "Entity" PrefixI True) (S1 (MetaSel (Just "entityKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Key record)) :*: S1 (MetaSel (Just "entityVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 record)))

data PersistValue #

A raw value which can be stored in any backend and can be marshalled to and from a PersistField.

Instances

Eq PersistValue
Instance details Defined in Database.Persist.Types.Base Methods (==) :: PersistValue -> PersistValue -> Bool # (/=) :: PersistValue -> PersistValue -> Bool #
Ord PersistValue
Instance details Defined in Database.Persist.Types.Base Methods compare :: PersistValue -> PersistValue -> Ordering # (<) :: PersistValue -> PersistValue -> Bool # (<=) :: PersistValue -> PersistValue -> Bool # (>) :: PersistValue -> PersistValue -> Bool # (>=) :: PersistValue -> PersistValue -> Bool # max :: PersistValue -> PersistValue -> PersistValue # min :: PersistValue -> PersistValue -> PersistValue #
Read PersistValue
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS PersistValue # readList :: ReadS [PersistValue] # readPrec :: ReadPrec PersistValue # readListPrec :: ReadPrec [PersistValue] #
Show PersistValue
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistValue -> ShowS # show :: PersistValue -> String # showList :: [PersistValue] -> ShowS #
ToJSON PersistValue
Instance details Defined in Database.Persist.Types.Base Methods toJSON :: PersistValue -> Value # toEncoding :: PersistValue -> Encoding # toJSONList :: [PersistValue] -> Value # toEncodingList :: [PersistValue] -> Encoding #
FromJSON PersistValue
Instance details Defined in Database.Persist.Types.Base Methods parseJSON :: Value -> Parser PersistValue # parseJSONList :: Value -> Parser [PersistValue] #
ToHttpApiData PersistValue
Instance details Defined in Database.Persist.Types.Base Methods toUrlPiece :: PersistValue -> Text # toEncodedUrlPiece :: PersistValue -> Builder # toHeader :: PersistValue -> ByteString # toQueryParam :: PersistValue -> Text #
FromHttpApiData PersistValue
Instance details Defined in Database.Persist.Types.Base Methods parseUrlPiece :: Text -> Either Text PersistValue # parseHeader :: ByteString -> Either Text PersistValue # parseQueryParam :: Text -> Either Text PersistValue #
PathPiece PersistValue
Instance details Defined in Database.Persist.Types.Base Methods fromPathPiece :: Text -> Maybe PersistValue # toPathPiece :: PersistValue -> Text #
PersistFieldSql PersistValue
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy PersistValue -> SqlType #
PersistField PersistValue
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: PersistValue -> PersistValue # fromPersistValue :: PersistValue -> Either Text PersistValue #

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)

Methods

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 #

Instances

MonadPersist backend m => MonadPersist backend (NoLoggingT m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> NoLoggingT m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> NoLoggingT m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> NoLoggingT m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> NoLoggingT m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> NoLoggingT m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> NoLoggingT m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> NoLoggingT m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> NoLoggingT m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> NoLoggingT m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> NoLoggingT m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> NoLoggingT m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> NoLoggingT m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> NoLoggingT m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> NoLoggingT m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> NoLoggingT m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> NoLoggingT m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> NoLoggingT m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> NoLoggingT m () Source # parseMigration :: Migration -> NoLoggingT m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> NoLoggingT m CautiousMigration Source # printMigration :: Migration -> NoLoggingT m () Source # showMigration :: Migration -> NoLoggingT m [Text] Source # getMigration :: Migration -> NoLoggingT m [Sql] Source # runMigration :: Migration -> NoLoggingT m () Source # runMigrationSilent :: Migration -> NoLoggingT m [Text] Source # runMigrationUnsafe :: Migration -> NoLoggingT m () Source # rawExecute :: Text -> [PersistValue] -> NoLoggingT m () Source # rawExecuteCount :: Text -> [PersistValue] -> NoLoggingT m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> NoLoggingT m [a] Source # transactionSave :: NoLoggingT m () Source # transactionUndo :: NoLoggingT m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> NoLoggingT m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> NoLoggingT m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> NoLoggingT m record Source #
MonadPersist backend m => MonadPersist backend (LoggingT m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> LoggingT m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> LoggingT m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> LoggingT m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> LoggingT m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> LoggingT m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> LoggingT m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> LoggingT m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> LoggingT m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> LoggingT m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> LoggingT m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> LoggingT m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> LoggingT m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> LoggingT m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> LoggingT m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> LoggingT m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> LoggingT m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> LoggingT m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> LoggingT m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> LoggingT m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> LoggingT m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> LoggingT m () Source # parseMigration :: Migration -> LoggingT m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> LoggingT m CautiousMigration Source # printMigration :: Migration -> LoggingT m () Source # showMigration :: Migration -> LoggingT m [Text] Source # getMigration :: Migration -> LoggingT m [Sql] Source # runMigration :: Migration -> LoggingT m () Source # runMigrationSilent :: Migration -> LoggingT m [Text] Source # runMigrationUnsafe :: Migration -> LoggingT m () Source # rawExecute :: Text -> [PersistValue] -> LoggingT m () Source # rawExecuteCount :: Text -> [PersistValue] -> LoggingT m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> LoggingT m [a] Source # transactionSave :: LoggingT m () Source # transactionUndo :: LoggingT m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> LoggingT m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> LoggingT m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> LoggingT m record Source #
(Monoid w, MonadPersist backend m) => MonadPersist backend (WriterT w m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> WriterT w m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> WriterT w m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> WriterT w m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> WriterT w m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> WriterT w m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> WriterT w m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> WriterT w m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> WriterT w m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> WriterT w m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> WriterT w m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> WriterT w m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> WriterT w m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> WriterT w m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> WriterT w m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> WriterT w m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> WriterT w m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> WriterT w m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> WriterT w m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> WriterT w m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> WriterT w m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> WriterT w m () Source # parseMigration :: Migration -> WriterT w m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> WriterT w m CautiousMigration Source # printMigration :: Migration -> WriterT w m () Source # showMigration :: Migration -> WriterT w m [Text] Source # getMigration :: Migration -> WriterT w m [Sql] Source # runMigration :: Migration -> WriterT w m () Source # runMigrationSilent :: Migration -> WriterT w m [Text] Source # runMigrationUnsafe :: Migration -> WriterT w m () Source # rawExecute :: Text -> [PersistValue] -> WriterT w m () Source # rawExecuteCount :: Text -> [PersistValue] -> WriterT w m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> WriterT w m [a] Source # transactionSave :: WriterT w m () Source # transactionUndo :: WriterT w m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> WriterT w m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> WriterT w m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> WriterT w m record Source #
MonadPersist backend m => MonadPersist backend (StateT s m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> StateT s m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> StateT s m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> StateT s m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> StateT s m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> StateT s m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> StateT s m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> StateT s m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> StateT s m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> StateT s m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> StateT s m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> StateT s m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> StateT s m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> StateT s m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> StateT s m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> StateT s m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> StateT s m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> StateT s m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> StateT s m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> StateT s m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> StateT s m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> StateT s m () Source # parseMigration :: Migration -> StateT s m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> StateT s m CautiousMigration Source # printMigration :: Migration -> StateT s m () Source # showMigration :: Migration -> StateT s m [Text] Source # getMigration :: Migration -> StateT s m [Sql] Source # runMigration :: Migration -> StateT s m () Source # runMigrationSilent :: Migration -> StateT s m [Text] Source # runMigrationUnsafe :: Migration -> StateT s m () Source # rawExecute :: Text -> [PersistValue] -> StateT s m () Source # rawExecuteCount :: Text -> [PersistValue] -> StateT s m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> StateT s m [a] Source # transactionSave :: StateT s m () Source # transactionUndo :: StateT s m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> StateT s m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> StateT s m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> StateT s m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> StateT s m record Source #
MonadPersist backend m => MonadPersist backend (IdentityT m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> IdentityT m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> IdentityT m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> IdentityT m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> IdentityT m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> IdentityT m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> IdentityT m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> IdentityT m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> IdentityT m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> IdentityT m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> IdentityT m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> IdentityT m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> IdentityT m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> IdentityT m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> IdentityT m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> IdentityT m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> IdentityT m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> IdentityT m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> IdentityT m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> IdentityT m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> IdentityT m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> IdentityT m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> IdentityT m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> IdentityT m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> IdentityT m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> IdentityT m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> IdentityT m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> IdentityT m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> IdentityT m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> IdentityT m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> IdentityT m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> IdentityT m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> IdentityT m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> IdentityT m () Source # parseMigration :: Migration -> IdentityT m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> IdentityT m CautiousMigration Source # printMigration :: Migration -> IdentityT m () Source # showMigration :: Migration -> IdentityT m [Text] Source # getMigration :: Migration -> IdentityT m [Sql] Source # runMigration :: Migration -> IdentityT m () Source # runMigrationSilent :: Migration -> IdentityT m [Text] Source # runMigrationUnsafe :: Migration -> IdentityT m () Source # rawExecute :: Text -> [PersistValue] -> IdentityT m () Source # rawExecuteCount :: Text -> [PersistValue] -> IdentityT m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> IdentityT m [a] Source # transactionSave :: IdentityT m () Source # transactionUndo :: IdentityT m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> IdentityT m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> IdentityT m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> IdentityT m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> IdentityT m record Source #
MonadPersist backend m => MonadPersist backend (ExceptT e m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ExceptT e m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ExceptT e m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> ExceptT e m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ExceptT e m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ExceptT e m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ExceptT e m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ExceptT e m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> ExceptT e m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> ExceptT e m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> ExceptT e m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> ExceptT e m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> ExceptT e m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> ExceptT e m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ExceptT e m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> ExceptT e m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ExceptT e m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> ExceptT e m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ExceptT e m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> ExceptT e m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ExceptT e m () Source # parseMigration :: Migration -> ExceptT e m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> ExceptT e m CautiousMigration Source # printMigration :: Migration -> ExceptT e m () Source # showMigration :: Migration -> ExceptT e m [Text] Source # getMigration :: Migration -> ExceptT e m [Sql] Source # runMigration :: Migration -> ExceptT e m () Source # runMigrationSilent :: Migration -> ExceptT e m [Text] Source # runMigrationUnsafe :: Migration -> ExceptT e m () Source # rawExecute :: Text -> [PersistValue] -> ExceptT e m () Source # rawExecuteCount :: Text -> [PersistValue] -> ExceptT e m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> ExceptT e m [a] Source # transactionSave :: ExceptT e m () Source # transactionUndo :: ExceptT e m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> ExceptT e m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ExceptT e m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ExceptT e m record Source #
MonadBaseControl IO m => MonadPersist backend (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> PersistT backend m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> PersistT backend m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> PersistT backend m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> PersistT backend m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> PersistT backend m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> PersistT backend m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> PersistT backend m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> PersistT backend m () Source # parseMigration :: Migration -> PersistT backend m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> PersistT backend m CautiousMigration Source # printMigration :: Migration -> PersistT backend m () Source # showMigration :: Migration -> PersistT backend m [Text] Source # getMigration :: Migration -> PersistT backend m [Sql] Source # runMigration :: Migration -> PersistT backend m () Source # runMigrationSilent :: Migration -> PersistT backend m [Text] Source # runMigrationUnsafe :: Migration -> PersistT backend m () Source # rawExecute :: Text -> [PersistValue] -> PersistT backend m () Source # rawExecuteCount :: Text -> [PersistValue] -> PersistT backend m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> PersistT backend m [a] Source # transactionSave :: PersistT backend m () Source # transactionUndo :: PersistT backend m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> PersistT backend m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m record Source #
MonadPersist backend m => MonadPersist backend (ReaderT r m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT r m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ReaderT r m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> ReaderT r m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> ReaderT r m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT r m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT r m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> ReaderT r m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ReaderT r m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT r m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT r m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT r m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> ReaderT r m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> ReaderT r m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> ReaderT r m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> ReaderT r m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> ReaderT r m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT r m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> ReaderT r m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT r m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT r m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> ReaderT r m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT r m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> ReaderT r m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT r m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT r m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> ReaderT r m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ReaderT r m () Source # parseMigration :: Migration -> ReaderT r m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> ReaderT r m CautiousMigration Source # printMigration :: Migration -> ReaderT r m () Source # showMigration :: Migration -> ReaderT r m [Text] Source # getMigration :: Migration -> ReaderT r m [Sql] Source # runMigration :: Migration -> ReaderT r m () Source # runMigrationSilent :: Migration -> ReaderT r m [Text] Source # runMigrationUnsafe :: Migration -> ReaderT r m () Source # rawExecute :: Text -> [PersistValue] -> ReaderT r m () Source # rawExecuteCount :: Text -> [PersistValue] -> ReaderT r m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> ReaderT r m [a] Source # transactionSave :: ReaderT r m () Source # transactionUndo :: ReaderT r m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> ReaderT r m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> ReaderT r m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> ReaderT r m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> ReaderT r m record Source #
(Monoid w, MonadPersist backend m) => MonadPersist backend (RWST r w s m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> RWST r w s m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> RWST r w s m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> RWST r w s m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> RWST r w s m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> RWST r w s m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> RWST r w s m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> RWST r w s m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> RWST r w s m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> RWST r w s m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> RWST r w s m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> RWST r w s m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> RWST r w s m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> RWST r w s m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> RWST r w s m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> RWST r w s m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> RWST r w s m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> RWST r w s m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> RWST r w s m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> RWST r w s m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> RWST r w s m () Source # parseMigration :: Migration -> RWST r w s m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> RWST r w s m CautiousMigration Source # printMigration :: Migration -> RWST r w s m () Source # showMigration :: Migration -> RWST r w s m [Text] Source # getMigration :: Migration -> RWST r w s m [Sql] Source # runMigration :: Migration -> RWST r w s m () Source # runMigrationSilent :: Migration -> RWST r w s m [Text] Source # runMigrationUnsafe :: Migration -> RWST r w s m () Source # rawExecute :: Text -> [PersistValue] -> RWST r w s m () Source # rawExecuteCount :: Text -> [PersistValue] -> RWST r w s m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> RWST r w s m [a] Source # transactionSave :: RWST r w s m () Source # transactionUndo :: RWST r w s m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> RWST r w s m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> RWST r w s m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> RWST r w s m record 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.

Instances

MonadBase b m => MonadBase b (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods liftBase :: b α -> PersistT backend m α #
MonadBaseControl b m => MonadBaseControl b (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist 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 #
MonadWriter w m => MonadWriter w (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist 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 #
MonadState s m => MonadState s (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: PersistT backend m s # put :: s -> PersistT backend m () # state :: (s -> (a, s)) -> PersistT backend m a #
MonadReader r m => MonadReader r (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods ask :: PersistT backend m r # local :: (r -> r) -> PersistT backend m a -> PersistT backend m a # reader :: (r -> a) -> PersistT backend m a #
MonadError e m => MonadError e (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods throwError :: e -> PersistT backend m a # catchError :: PersistT backend m a -> (e -> PersistT backend m a) -> PersistT backend m a #
MonadBaseControl IO m => MonadPersist backend (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods get :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe record) Source # insert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Key record) Source # insert_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m () Source # insertMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m [Key record] Source # insertMany_ :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [record] -> PersistT backend m () Source # insertEntityMany :: (PersistStoreWrite backend, PersistRecordBackend record backend) => [Entity record] -> PersistT backend m () Source # insertKey :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # repsert :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # replace :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> record -> PersistT backend m () Source # delete :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m () Source # update :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m () Source # updateGet :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> [Update record] -> PersistT backend m record Source # getJust :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m record Source # belongsTo :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Maybe (Key record2)) -> record1 -> PersistT backend m (Maybe record2) Source # belongsToJust :: (PersistStoreRead backend, PersistRecordBackend record1 backend, PersistRecordBackend record2 backend) => (record1 -> Key record2) -> record1 -> PersistT backend m record2 Source # insertEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Entity record) Source # getBy :: (PersistUniqueRead backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m (Maybe (Entity record)) Source # deleteBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> PersistT backend m () Source # insertUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Key record)) Source # upsert :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> [Update record] -> PersistT backend m (Entity record) Source # getByValue :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Entity record)) Source # insertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Either (Entity record) (Key record)) Source # replaceUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend, Eq record, Eq (Unique record)) => Key record -> record -> PersistT backend m (Maybe (Unique record)) Source # checkUnique :: (PersistUniqueRead backend, PersistRecordBackend record backend) => record -> PersistT backend m (Maybe (Unique record)) Source # onlyUnique :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m (Unique record) Source # selectFirst :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m (Maybe (Entity record)) Source # count :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m Int Source # updateWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> PersistT backend m () Source # deleteWhere :: (PersistQueryWrite backend, PersistRecordBackend record backend) => [Filter record] -> PersistT backend m () Source # selectList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Entity record] Source # selectKeysList :: (PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> PersistT backend m [Key record] Source # deleteCascade :: DeleteCascade record backend => Key record -> PersistT backend m () Source # deleteCascadeWhere :: (DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> PersistT backend m () Source # parseMigration :: Migration -> PersistT backend m (Either [Text] CautiousMigration) Source # parseMigration' :: Migration -> PersistT backend m CautiousMigration Source # printMigration :: Migration -> PersistT backend m () Source # showMigration :: Migration -> PersistT backend m [Text] Source # getMigration :: Migration -> PersistT backend m [Sql] Source # runMigration :: Migration -> PersistT backend m () Source # runMigrationSilent :: Migration -> PersistT backend m [Text] Source # runMigrationUnsafe :: Migration -> PersistT backend m () Source # rawExecute :: Text -> [PersistValue] -> PersistT backend m () Source # rawExecuteCount :: Text -> [PersistValue] -> PersistT backend m Int64 Source # rawSql :: (backend ~ SqlBackend, RawSql a) => Text -> [PersistValue] -> PersistT backend m [a] Source # transactionSave :: PersistT backend m () Source # transactionUndo :: PersistT backend m () Source # upsertBy :: (PersistUniqueWrite backend, PersistRecordBackend record backend) => Unique record -> record -> [Update record] -> PersistT backend m (Entity record) Source # getJustEntity :: (PersistStoreRead backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Entity record) Source # getEntity :: (PersistStoreWrite backend, PersistRecordBackend record backend) => Key record -> PersistT backend m (Maybe (Entity record)) Source # insertRecord :: (PersistStoreWrite backend, PersistRecordBackend record backend) => record -> PersistT backend m record Source #
MonadTrans (PersistT backend) Source #
Instance details Defined in Control.Monad.Persist Methods lift :: Monad m => m a -> PersistT backend m a #
MonadTransControl (PersistT backend) Source #
Instance details Defined in Control.Monad.Persist 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) Source #
Instance details Defined in Control.Monad.Persist 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) Source #
Instance details Defined in Control.Monad.Persist 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) Source #
Instance details Defined in Control.Monad.Persist Methods pure :: a -> PersistT backend m a # (<>) :: PersistT backend m (a -> b) -> PersistT backend m a -> PersistT backend m b # liftA2 :: (a -> b -> c) -> PersistT backend m a -> PersistT backend m b -> PersistT backend m c # (>) :: 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) Source #
Instance details Defined in Control.Monad.Persist Methods liftIO :: IO a -> PersistT backend m a #
MonadThrow m => MonadThrow (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods throwM :: Exception e => e -> PersistT backend m a #
MonadCatch m => MonadCatch (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods catch :: Exception e => PersistT backend m a -> (e -> PersistT backend m a) -> PersistT backend m a #
MonadMask m => MonadMask (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods mask :: ((forall a. PersistT backend m a -> PersistT backend m a) -> PersistT backend m b) -> PersistT backend m b # uninterruptibleMask :: ((forall a. PersistT backend m a -> PersistT backend m a) -> PersistT backend m b) -> PersistT backend m b # generalBracket :: PersistT backend m a -> (a -> ExitCase b -> PersistT backend m c) -> (a -> PersistT backend m b) -> PersistT backend m (b, c) #
MonadLogger m => MonadLogger (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> PersistT backend m () #
MonadLoggerIO m => MonadLoggerIO (PersistT backend m) Source #
Instance details Defined in Control.Monad.Persist Methods askLoggerIO :: PersistT backend m (Loc -> LogSource -> LogLevel -> LogStr -> IO ()) #
type StT (PersistT backend) a Source #
Instance details Defined in Control.Monad.Persist type StT (PersistT backend) a = StT (ReaderT SqlBackend :: (* -> ) -> -> *) a
type StM (PersistT backend m) a Source #
Instance details Defined in Control.Monad.Persist type StM (PersistT backend m) a = ComposeSt (PersistT backend) m a

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.