Modulepersistent-2.14.6.3Haskell2010

Database.Persist.Class.PersistStore

1 type
7 classes
10 values

Packagepersistent-2.14.6.3
Exports18
LanguageHaskell2010
LicenceMIT
SourcePersistStore.hs

classclass HasPersistBackend backend where

Class which allows the plucking of a BaseBackend backend from some larger type. For example, instance HasPersistBackend (SqlReadBackend, Int) where type BaseBackend (SqlReadBackend, Int) = SqlBackend persistBackend = unSqlReadBackend . fst

Associated types

type family BaseBackend backend

Methods

persistBackend :: backend -> BaseBackend backend

Instances4HasPersistBackend

HasPersistBackend SqlReadBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Types.Internal
HasPersistBackend SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Types.Internal
HasPersistBackend SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.SqlBackend.Internal
(BackendCompatible b s, HasPersistBackend b) => HasPersistBackend (Compatible b s)Defined in persistent-2.14.6.3 · Database.Persist.Compatible.Types

valuewithBaseBackend

:: HasPersistBackend backend
=> ReaderT (BaseBackend backend) m a
-> ReaderT backend m a

Run a query against a larger backend by plucking out BaseBackend backend

This is a helper for reusing existing queries when expanding the backend type.

classclass HasPersistBackend backend => IsPersistBackend backend where

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.

Methods

mkPersistBackend :: BaseBackend backend -> backend
This function is how we actually construct and tag a backend as having read or write capabilities. It should be used carefully and only when actually constructing a backend. Careless use allows us to accidentally run a write query against a read-only database.

Instances3IsPersistBackend

IsPersistBackend SqlReadBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Types.Internal
IsPersistBackend SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Types.Internal
IsPersistBackend SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.SqlBackend.Internal

typetype PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

A convenient alias for common type signatures

valueliftPersist

:: (MonadIO m, MonadReader backend m)
=> ReaderT backend IO b
-> m b

classclass PersistCore backend where

Associated types

data family BackendKey backend

Instances4PersistCore

PersistCore SqlReadBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
PersistCore SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
PersistCore SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
(BackendCompatible b s, PersistCore b) => PersistCore (Compatible b s)Defined in persistent-2.14.6.3 · Database.Persist.Compatible.Types

class

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 where

Methods

get :: (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe record)
Get a record by identifier, if available.
Example usage
With schema-1 and dataset-1,
```
getSpj :: MonadIO m => ReaderT SqlBackend m (Maybe User)
getSpj = get spjId
```
```
mspj <- getSpj
```
The above query when applied on dataset-1, will get this:
```
+------+-----+
| name | age |
+------+-----+
| SPJ  |  40 |
+------+-----+
```
getMany :: (MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)
Get many records by their respective identifiers, if available.
Example usage
With schema-1 and dataset-1:
```
getUsers :: MonadIO m => ReaderT SqlBackend m (Map (Key User) User)
getUsers = getMany allkeys
```
```
musers <- getUsers
```
The above query when applied on dataset-1, will get these records:
```
+----+-------+-----+
| id | name  | age |
+----+-------+-----+
|  1 | SPJ   |  40 |
+----+-------+-----+
|  2 | Simon |  41 |
+----+-------+-----+
```

Instances4PersistStoreRead

PersistStoreRead SqlReadBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
PersistStoreRead SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
PersistStoreRead SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
(HasPersistBackend b, BackendCompatible b s, PersistStoreRead b) => PersistStoreRead (Compatible b s)Defined in persistent-2.14.6.3 · Database.Persist.Compatible.Types

class

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 where

Methods

insert :: (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)
Create a new record in the database, returning an automatically created key (in SQL an auto-increment id).
Example usage
Using schema-1 and dataset-1, let's insert a new user John.
```
insertJohn :: MonadIO m => ReaderT SqlBackend m (Key User)
insertJohn = insert $ User "John" 30
```
```
johnId <- insertJohn
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+
```

insert_ :: (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()

Same as insert, but doesn't return a Key.

Example usage

with schema-1 and dataset-1,

insertJohn :: MonadIO m => ReaderT SqlBackend m (Key User)
insertJohn = insert_ $ User "John" 30

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+

insertMany :: (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]
Create multiple records in the database and return their Keys.
If you don't need the inserted Keys, use insertMany_.
The MongoDB and PostgreSQL backends insert all records and retrieve their keys in one database query.
The SQLite and MySQL backends use the slow, default implementation of mapM insert.
Example usage
with schema-1 and dataset-1,
```
insertUsers :: MonadIO m => ReaderT SqlBackend m [Key User]
insertUsers = insertMany [User "John" 30, User "Nick" 32, User "Jane" 20]
```
```
userIds <- insertUsers
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+
|4    |Nick  |32   |
+-----+------+-----+
|5    |Jane  |20   |
+-----+------+-----+
```

insertMany_ :: (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()

Same as insertMany, but doesn't return any Keys.

The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.

Example usage

With schema-1 and dataset-1,

insertUsers_ :: MonadIO m => ReaderT SqlBackend m ()
insertUsers_ = insertMany_ [User "John" 30, User "Nick" 32, User "Jane" 20]

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+
|4    |Nick  |32   |
+-----+------+-----+
|5    |Jane  |20   |
+-----+------+-----+

insertEntityMany :: (MonadIO m, PersistRecordBackend record backend) => [Entity record] -> ReaderT backend m ()
Same as insertMany_, but takes an Entity instead of just a record.
Useful when migrating data from one entity to another and want to preserve ids.
The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.
Example usage
With schema-1 and dataset-1,
```
insertUserEntityMany :: MonadIO m => ReaderT SqlBackend m ()
insertUserEntityMany = insertEntityMany [SnakeEntity, EvaEntity]
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Snake |38   |
+-----+------+-----+
|4    |Eva   |38   |
+-----+------+-----+
```

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

Create a new record in the database using the given key.

Example usage

With schema-1 and dataset-1,

insertAliceKey :: MonadIO m => Key User -> ReaderT SqlBackend m ()
insertAliceKey key = insertKey key $ User "Alice" 20

insertAliceKey $ UserKey {unUserKey = SqlBackendKey {unSqlBackendKey = 3}}

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Alice |20   |
+-----+------+-----+

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

Put the record in the database with the given key. Unlike replace, if a record with the given key does not exist then a new record will be inserted.

Example usage

We try to explain upsertBy using schema-1 and dataset-1.

First, we insert Philip to dataset-1.

insertPhilip :: MonadIO m => ReaderT SqlBackend m (Key User)
insertPhilip = insert $ User "Philip" 42

philipId <- insertPhilip

This query will produce:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Philip|42   |
+-----+------+-----+

repsertHaskell :: MonadIO m => Key record -> ReaderT SqlBackend m ()
repsertHaskell id = repsert id $ User "Haskell" 81

repsertHaskell philipId

This query will replace Philip's record with Haskell's one:

+-----+-----------------+--------+
|id   |name             |age     |
+-----+-----------------+--------+
|1    |SPJ              |40      |
+-----+-----------------+--------+
|2    |Simon            |41      |
+-----+-----------------+--------+
|3    |Philip -> Haskell|42 -> 81|
+-----+-----------------+--------+

repsert inserts the given record if the key doesn't exist.

repsertXToUnknown :: MonadIO m => ReaderT SqlBackend m ()
repsertXToUnknown = repsert unknownId $ User "X" 999

For example, applying the above query to dataset-1 will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |X     |999  |
+-----+------+-----+

repsertMany :: (MonadIO m, PersistRecordBackend record backend) => [(Key record, record)] -> ReaderT backend m ()

Put many entities into the database.

Batch version of repsert for SQL backends.

Useful when migrating data from one entity to another and want to preserve ids.

Example usage

With schema-1 and dataset-1,

repsertManyUsers :: MonadIO m =>ReaderT SqlBackend m ()
repsertManyusers = repsertMany [(simonId, User "Philip" 20), (unknownId999, User "Mr. X" 999)]

The above query when applied on dataset-1, will produce this:

+-----+----------------+---------+
|id   |name            |age      |
+-----+----------------+---------+
|1    |SPJ             |40       |
+-----+----------------+---------+
|2    |Simon -> Philip |41 -> 20 |
+-----+----------------+---------+
|999  |Mr. X           |999      |
+-----+----------------+---------+

replace :: (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()
Replace the record in the database with the given key. Note that the result is undefined if such record does not exist, so you must use insertKey or repsert in these cases.
Example usage
With schema-1 schama-1 and dataset-1,
```
replaceSpj :: MonadIO m => User -> ReaderT SqlBackend m ()
replaceSpj record = replace spjId record
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |Mike  |45   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
```
delete :: (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m ()
Delete a specific record by identifier. Does nothing if record does not exist.
Example usage
With schema-1 and dataset-1,
```
deleteSpj :: MonadIO m => ReaderT SqlBackend m ()
deleteSpj = delete spjId
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
```

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

Update individual fields on a specific record.

Example usage

With schema-1 and dataset-1,

updateSpj :: MonadIO m => [Update User] -> ReaderT SqlBackend m ()
updateSpj updates = update spjId updates

updateSpj [UserAge +=. 100]

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |140  |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+

updateGet :: (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record
Update individual fields on a specific record, and retrieve the updated value from the database.
Note that this function will throw an exception if the given key is not found in the database.
Example usage
With schema-1 and dataset-1,
```
updateGetSpj :: MonadIO m => [Update User] -> ReaderT SqlBackend m User
updateGetSpj updates = updateGet spjId updates
```
```
spj <- updateGetSpj [UserAge +=. 100]
```
The above query when applied on dataset-1, will produce this:
```
+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |140  |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
```

Instances3PersistStoreWrite

PersistStoreWrite SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
PersistStoreWrite SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
(HasPersistBackend b, BackendCompatible b s, PersistStoreWrite b) => PersistStoreWrite (Compatible b s)Defined in persistent-2.14.6.3 · Database.Persist.Compatible.Types

valuegetEntity

:: (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m)
=> Key e
-> ReaderT backend m (Maybe (Entity e))

Like get, but returns the complete Entity.

Example usage

With schema-1 and dataset-1,

getSpjEntity :: MonadIO m => ReaderT SqlBackend m (Maybe (Entity User))
getSpjEntity = getEntity spjId

mSpjEnt <- getSpjEntity

The above query when applied on dataset-1, will get this entity:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

valuegetJust

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

Same as get, but for a non-null (not Maybe) foreign key. Unsafe unless your database is enforcing that the foreign key is valid.

Example usage

With schema-1 and dataset-1,

getJustSpj :: MonadIO m => ReaderT SqlBackend m User
getJustSpj = getJust spjId

spj <- getJust spjId

The above query when applied on dataset-1, will get this record:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

getJustUnknown :: MonadIO m => ReaderT SqlBackend m User
getJustUnknown = getJust unknownId

mrx <- getJustUnknown

This just throws an error.

valuegetJustEntity

:: (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend)
=> Key record
-> ReaderT backend m (Entity record)

Same as getJust, but returns an Entity instead of just the record.

Example usage

With schema-1 and dataset-1,

getJustEntitySpj :: MonadIO m => ReaderT SqlBackend m (Entity User)
getJustEntitySpj = getJustEntity spjId

spjEnt <- getJustEntitySpj

The above query when applied on dataset-1, will get this entity:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

valuebelongsTo

:: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m)
=> ent1 -> Maybe (Key ent2)
-> ent1
-> ReaderT backend m (Maybe ent2)

Curry this to make a convenience function that loads an associated model.

foreign = belongsTo foreignId

valuebelongsToJust

:: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m)
=> ent1 -> Key ent2
-> ent1
-> ReaderT backend m ent2

Same as belongsTo, but uses getJust and therefore is similarly unsafe.

valueinsertEntity

:: (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack)
=> e
-> ReaderT backend m (Entity e)

Like insert, but returns the complete Entity.

Example usage

With schema-1 and dataset-1,

insertHaskellEntity :: MonadIO m => ReaderT SqlBackend m (Entity User)
insertHaskellEntity = insertEntity $ User "Haskell" 81

haskellEnt <- insertHaskellEntity

The above query when applied on dataset-1, will produce this:

+----+---------+-----+
| id |  name   | age |
+----+---------+-----+
|  1 | SPJ     |  40 |
+----+---------+-----+
|  2 | Simon   |  41 |
+----+---------+-----+
|  3 | Haskell |  81 |
+----+---------+-----+

valueinsertRecord

:: (PersistEntityBackend record ~ BaseBackend backend, PersistEntity record, MonadIO m, PersistStoreWrite backend, SafeToInsert record, HasCallStack)
=> record
-> ReaderT backend m record

Like insertEntity but just returns the record instead of Entity.

Example usage

With schema-1 and dataset-1,

insertDaveRecord :: MonadIO m => ReaderT SqlBackend m User
insertDaveRecord = insertRecord $ User "Dave" 50

dave <- insertDaveRecord

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Dave  |50   |
+-----+------+-----+

class

class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where

ToBackendKey converts a PersistEntity Key into a BackendKey This can be used by each backend to convert between a Key and a plain Haskell type. For Sql, that is done with toSqlKey and fromSqlKey.

By default, a PersistEntity uses the default BackendKey for its Key and is an instance of ToBackendKey

A Key that instead uses a custom type will not be an instance of ToBackendKey.

Methods

toBackendKey :: Key record -> BackendKey backend
fromBackendKey :: BackendKey backend -> Key record

classclass BackendCompatible sup sub where

This class witnesses that two backend are compatible, and that you can convert from the sub backend into the sup backend. This is similar to the HasPersistBackend and IsPersistBackend classes, but where you don't want to fix the type associated with the PersistEntityBackend of a record.

Generally speaking, where you might have:

foo ::
  ( PersistEntity record
  , PersistEntityBackend record ~ BaseBackend backend
  , IsSqlBackend backend
  )

this can be replaced with:

foo ::
  ( PersistEntity record,
  , PersistEntityBackend record ~ backend
  , BackendCompatible SqlBackend backend
  )

This works for SqlReadBackend because of the instance BackendCompatible SqlBackend SqlReadBackend, without needing to go through the BaseBackend type family.

Likewise, functions that are currently hardcoded to use SqlBackend can be generalized:

-- before:
asdf :: ReaderT SqlBackend m ()
asdf = pure ()

-- after:
asdf' :: BackendCompatible SqlBackend backend => ReaderT backend m ()
asdf' = withCompatibleBackend asdf

Methods

projectBackend :: sub -> sup

Instances3BackendCompatible

BackendCompatible SqlBackend SqlReadBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
BackendCompatible SqlBackend SqlWriteBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan
BackendCompatible SqlBackend SqlBackendDefined in persistent-2.14.6.3 · Database.Persist.Sql.Orphan.PersistStore · orphan

valuewithCompatibleBackend

:: BackendCompatible sup sub
=> ReaderT sup m a
-> ReaderT sub m a

Run a query against a compatible backend, by projecting the backend

This is a helper for using queries which run against a specific backend type that your backend is compatible with.