Database.Persist.TH

This module provides the tools for defining your database schema and using it to generate Haskell data types and migrations.

Parse entity defs

persistWith :: PersistSettings -> QuasiQuoter

Converts a quasi-quoted syntax into a list of entity definitions, to be used as input to the template haskell generation code (mkPersist).

persistUpperCase :: QuasiQuoter

Apply persistWith to upperCaseSettings.

persistLowerCase :: QuasiQuoter

Apply persistWith to lowerCaseSettings.

persistFileWith :: PersistSettings -> FilePath -> Q Exp

Same as persistWith, but uses an external file instead of a quasiquotation. The recommended file extension is .persistentmodels.

persistManyFileWith :: PersistSettings -> [FilePath] -> Q Exp

Same as persistFileWith, but uses several external files instead of one. Splitting your Persistent definitions into multiple modules can potentially dramatically speed up compile times.

The recommended file extension is .persistentmodels.

Examples

Split your Persistent definitions into multiple files (models1, models2), then create a new module for each new file and run mkPersist there:

-- Model1.hs
share
    [mkPersist sqlSettings]
    $(persistFileWith lowerCaseSettings "models1")

-- Model2.hs
share
    [mkPersist sqlSettings]
    $(persistFileWith lowerCaseSettings "models2")

Use persistManyFileWith to create your migrations:

-- Migrate.hs
share
    [mkMigrate "migrateAll"]
    $(persistManyFileWith lowerCaseSettings ["models1.persistentmodels","models2.persistentmodels"])

Tip: To get the same import behavior as if you were declaring all your models in one file, import your new files as Name into another file, then export module Name.

This approach may be used in the future to reduce memory usage during compilation, but so far we've only seen mild reductions.

See persistent#778 and persistent#791 for more details.

Since: 2.5.4

Turn EntityDefs into types

mkPersist :: MkPersistSettings -> [EntityDef] -> Q [Dec]

Create data types and appropriate PersistEntity instances for the given EntityDefs. Works well with the persist quasi-quoter.

data MkPersistSettings

Settings to be passed to the mkPersist function.

mpsBackend :: MkPersistSettings -> Type

Which database backend we're using.

When generating data types, each type is given a generic version- which works with any backend- and a type synonym for the commonly used backend. This is where you specify that commonly used backend.

mpsGeneric :: MkPersistSettings -> Bool

Create generic types that can be used with multiple backends. Good for reusable code, but makes error messages harder to understand. Default: False.

mpsPrefixFields :: MkPersistSettings -> Bool

Prefix field names with the model name. Default: True.

Note: this field is deprecated. Use the mpsFieldLabelModifier and mpsConstraintLabelModifier instead.

mpsFieldLabelModifier :: MkPersistSettings -> Text -> Text -> Text

Customise the field accessors and lens names using the entity and field name. Both arguments are upper cased.

Default: appends entity and field.

Note: this setting is ignored if mpsPrefixFields is set to False. @since 2.11.0.0

mpsConstraintLabelModifier :: MkPersistSettings -> Text -> Text -> Text

Customise the Constraint names using the entity and field name. The result should be a valid haskell type (start with an upper cased letter).

Default: appends entity and field

Note: this setting is ignored if mpsPrefixFields is set to False. @since 2.11.0.0

mpsEntityJSON :: MkPersistSettings -> Maybe EntityJSON

Generate ToJSON/FromJSON instances for each model types. If it's Nothing, no instances will be generated. Default:

 Just EntityJSON
     { entityToJSON = 'entityIdToJSON
     , entityFromJSON = 'entityIdFromJSON
     }

mpsGenerateLenses :: MkPersistSettings -> Bool

Instead of generating normal field accessors, generator lens-style accessors.

Default: False

Since: 1.3.1

mpsDeriveInstances :: MkPersistSettings -> [Name]

Automatically derive these typeclass instances for all record and key types.

Default: []

Since: 2.8.1

data EntityJSON

Constructors

EntityJSON

Fields

• entityToJSON :: Name

  Name of the toJSON implementation for Entity a.

• entityFromJSON :: Name

  Name of the fromJSON implementation for Entity a.

mkPersistSettings

Arguments

:: Type

Value for mpsBackend

-> MkPersistSettings

Create an MkPersistSettings with default values.

sqlSettings :: MkPersistSettings

Use the SqlPersist backend.

Various other TH functions

mkMigrate :: String -> [EntityDef] -> Q [Dec]

Creates a single function to perform all migrations for the entities defined here. One thing to be aware of is dependencies: if you have entities with foreign references, make sure to place those definitions after the entities they reference.

mkSave :: String -> [EntityDef] -> Q [Dec]

Save the EntityDefs passed in under the given name.

mkDeleteCascade :: MkPersistSettings -> [EntityDef] -> Q [Dec]

Generate a DeleteCascade instance for the given EntityDefs.

mkEntityDefList

Arguments

:: String

The name that will be given to the EntityDef list.

-> [EntityDef]

-> Q [Dec]

Creates a declaration for the [EntityDef] from the persistent schema. This is necessary because the Persistent QuasiQuoter is unable to know the correct type of ID fields, and assumes that they are all Int64.

Provide this in the list you give to share, much like mkMigrate.

share [mkMigrate "migrateAll", mkEntityDefList "entityDefs"] [...]

Since: 2.7.1

share :: [[EntityDef] -> Q [Dec]] -> [EntityDef] -> Q [Dec]

Apply the given list of functions to the same EntityDefs.

This function is useful for cases such as:

>>> share [mkSave "myDefs", mkPersist sqlSettings] [persistLowerCase|...|]

derivePersistField :: String -> Q [Dec]

Automatically creates a valid PersistField instance for any datatype that has valid Show and Read instances. Can be very convenient for Enum types.

derivePersistFieldJSON :: String -> Q [Dec]

Automatically creates a valid PersistField instance for any datatype that has valid ToJSON and FromJSON instances. For a datatype T it generates instances similar to these:

   instance PersistField T where
       toPersistValue = PersistByteString . L.toStrict . encode
       fromPersistValue = (left T.pack) . eitherDecodeStrict' <=< fromPersistValue
   instance PersistFieldSql T where
       sqlType _ = SqlString

persistFieldFromEntity :: MkPersistSettings -> EntityDef -> Q [Dec]

Produce code similar to the following:

  instance PersistEntity e => PersistField e where
     toPersistValue = entityToPersistValueHelper
     fromPersistValue = entityFromPersistValueHelper ["col1", "col2"]
     sqlType _ = SqlString

Internal

lensPTH :: (s -> a) -> (s -> b -> t) -> Lens s t a b

parseReferences :: PersistSettings -> Text -> Q Exp

Since: 2.5.3

embedEntityDefs :: [EntityDef] -> [EntityDef]

Takes a list of (potentially) independently defined entities and properly links all foreign keys to reference the right EntityDef, tying the knot between entities.

Allows users to define entities indepedently or in separate modules and then fix the cross-references between them at runtime to create a Migration.

Since: 2.7.2

fieldError :: Text -> Text -> Text -> Text

Render an error message based on the tableName and fieldName with the provided message.

Since: 2.8.2

class PersistEntity record => AtLeastOneUniqueKey record where

This class is used to ensure that functions requring at least one unique key are not called with records that have 0 unique keys. The quasiquoter automatically writes working instances for appropriate entities, and generates TypeError instances for records that have 0 unique keys.

Since: 2.10.0

Methods

requireUniquesP :: record -> NonEmpty (Unique record)

class PersistEntity record => OnlyOneUniqueKey record where

This class is used to ensure that upsert is only called on records that have a single Unique key. The quasiquoter automatically generates working instances for appropriate records, and generates TypeError instances for records that have 0 or multiple unique keys.

Since: 2.10.0

Methods

onlyUniqueP :: record -> Unique record

pkNewtype :: MkPersistSettings -> EntityDef -> Bool

Returns True if the key definition has more than 1 field.

Since: 2.11.0.0