Database.Groundhog.Core

This module defines the functions and datatypes used throughout the framework. Most of them are for the internal use

Main types

class (PersistField v, PurePersistField (AutoKey v)) => PersistEntity v where

Only instances of this class can be persisted in a database

Associated Types

data Field v :: ((* -> *) -> *) -> * -> *

This type is used for typesafe manipulation of separate fields of datatype v. Each constructor in Field corresponds to its field in a datatype v. It is parametrised by constructor phantom type and field value type.

data Key v :: * -> *

A unique identifier of a value stored in a database. This may be a primary key, a constraint or unique indices. The second parameter is the key description.

type AutoKey v

This type is the default autoincremented key for the entity. If entity does not have such key, AutoKey v = ().

type DefaultKey v

This type is the default key for the entity.

Methods

entityDef :: v -> EntityDef

Returns a complete description of the type

toEntityPersistValues :: PersistBackend m => v -> m ([PersistValue] -> [PersistValue])

Marshalls value to a list of PersistValue ready for insert to a database

fromEntityPersistValues :: PersistBackend m => [PersistValue] -> m (v, [PersistValue])

Constructs the value from the list of PersistValue

getUniques :: DbDescriptor db => Proxy db -> v -> (Int, [(String, [PersistValue])])

Returns constructor number and a list of uniques names and corresponding field values

entityFieldChain :: Field v c a -> FieldChain

Is internally used by FieldLike Field instance We could avoid this function if class FieldLike allowed FieldLike Fields Data or FieldLike (Fields Data). However that would require additional extensions in user-space code

data PersistValue

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

Constructors

PersistString String

PersistByteString ByteString

PersistInt64 Int64

PersistDouble Double

PersistBool Bool

PersistDay Day

PersistTimeOfDay TimeOfDay

PersistUTCTime UTCTime

PersistZonedTime ZT

PersistNull

Instances

Eq PersistValue

Show PersistValue

class PersistField a where

Represents everything which can be put into a database. This data can be stored in multiple columns and tables. To get value of those columns we might need to access another table. That is why the result type is monadic.

Methods

persistName :: a -> String

Return name of the type. If it is polymorhic, the names of parameter types are separated with delim symbol

toPersistValues :: PersistBackend m => a -> m ([PersistValue] -> [PersistValue])

Convert a value into something which can be stored in a database column. Note that for complex datatypes it may insert them to return identifier

fromPersistValues :: PersistBackend m => [PersistValue] -> m (a, [PersistValue])

Constructs a value from a PersistValue. For complex datatypes it may query the database

dbType :: a -> DbType

Description of value type

Instances

PersistField Bool

PersistField Double

PersistField Int

PersistField Int8

PersistField Int16

PersistField Int32

PersistField Int64

PersistField Word8

PersistField Word16

PersistField Word32

PersistField Word64

PersistField String

PersistField ()

PersistField ByteString

PersistField Text

PersistField ZonedTime

PersistField TimeOfDay

PersistField UTCTime

PersistField Day

PersistField a => PersistField [a]

(PersistField a, NeverNull a) => PersistField (Maybe a)

(PersistField a, PersistField b) => PersistField (a, b)

(DbDescriptor db, PersistEntity v) => PersistField (KeyForBackend db v)

(PersistField a, PersistField b, PersistField c) => PersistField (a, b, c)

(PersistField a, PersistField b, PersistField c, PersistField d) => PersistField (a, b, c, d)

(PersistField a, PersistField b, PersistField c, PersistField d, PersistField e) => PersistField (a, b, c, d, e)

class PersistField a => SinglePersistField a where

Represents all datatypes that map into a single column. Getting value for that column might require monadic actions to access other tables.

Methods

toSinglePersistValue :: PersistBackend m => a -> m PersistValue

fromSinglePersistValue :: PersistBackend m => PersistValue -> m a

Instances

(PersistField a, PrimitivePersistField a) => SinglePersistField a

(PersistField (Maybe a), SinglePersistField a, NeverNull a) => SinglePersistField (Maybe a)

class PersistField a => PurePersistField a where

Represents all datatypes that map into several columns. Getting values for those columns is pure.

Methods

toPurePersistValues :: DbDescriptor db => Proxy db -> a -> [PersistValue] -> [PersistValue]

fromPurePersistValues :: DbDescriptor db => Proxy db -> [PersistValue] -> (a, [PersistValue])

Instances

PurePersistField ()

(PersistField a, PrimitivePersistField a) => PurePersistField a

(PersistField (Maybe a), PrimitivePersistField a, NeverNull a) => PurePersistField (Maybe a)

(PersistField (a, b), PurePersistField a, PurePersistField b) => PurePersistField (a, b)

(PersistField (a, b, c), PurePersistField a, PurePersistField b, PurePersistField c) => PurePersistField (a, b, c)

(PersistField (a, b, c, d), PurePersistField a, PurePersistField b, PurePersistField c, PurePersistField d) => PurePersistField (a, b, c, d)

(PersistField (a, b, c, d, e), PurePersistField a, PurePersistField b, PurePersistField c, PurePersistField d, PurePersistField e) => PurePersistField (a, b, c, d, e)

class (SinglePersistField a, PurePersistField a) => PrimitivePersistField a where

Datatypes which can be converted directly to PersistValue. The no-value parameter DbDescriptor db => Proxy db allows conversion depend the database details while keeping it pure.

Methods

toPrimitivePersistValue :: DbDescriptor db => Proxy db -> a -> PersistValue

fromPrimitivePersistValue :: DbDescriptor db => Proxy db -> PersistValue -> a

Instances

PrimitivePersistField Bool

PrimitivePersistField Double

PrimitivePersistField Int

PrimitivePersistField Int8

PrimitivePersistField Int16

PrimitivePersistField Int32

PrimitivePersistField Int64

PrimitivePersistField Word8

PrimitivePersistField Word16

PrimitivePersistField Word32

PrimitivePersistField Word64

PrimitivePersistField String

PrimitivePersistField ByteString

PrimitivePersistField Text

PrimitivePersistField ZonedTime

PrimitivePersistField TimeOfDay

PrimitivePersistField UTCTime

PrimitivePersistField Day

(SinglePersistField (Maybe a), PurePersistField (Maybe a), PrimitivePersistField a, NeverNull a) => PrimitivePersistField (Maybe a)

(SinglePersistField (KeyForBackend db v), PurePersistField (KeyForBackend db v), DbDescriptor db, PersistEntity v) => PrimitivePersistField (KeyForBackend db v)

class PersistField v => Embedded v where

Associated Types

data Selector v :: * -> *

Methods

selectorNum :: Selector v a -> Int

Instances

(PersistField (a', b'), PersistField a', PersistField b') => Embedded (a', b')

(PersistField (a', b', c'), PersistField a', PersistField b', PersistField c') => Embedded (a', b', c')

(PersistField (a', b', c', d'), PersistField a', PersistField b', PersistField c', PersistField d') => Embedded (a', b', c', d')

(PersistField (a', b', c', d', e'), PersistField a', PersistField b', PersistField c', PersistField d', PersistField e') => Embedded (a', b', c', d', e')

class Projection p r a | p -> r a where

Any data that can be fetched from a database

Methods

projectionFieldChains :: p -> [FieldChain] -> [FieldChain]

It is like a fieldChain for many fields. Difflist is used for concatenation efficiency.

projectionResult :: PersistBackend m => p -> [PersistValue] -> m (a, [PersistValue])

It is like fromPersistValues. However, we cannot use it for projections in all cases. For the PersistEntity instances fromPersistValues expects entity id instead of the entity values.

Instances

(PersistEntity v, IsUniqueKey (Key v (Unique u)), ~ * r (RestrictionHolder v (UniqueConstr (Key v (Unique u))))) => Projection (u (UniqueMarker v)) r (Key v (Unique u))

(PersistEntity v, Constructor c) => Projection (c (ConstructorMarker v)) (RestrictionHolder v c) v

(Projection a1 r a1', Projection a2 r a2') => Projection (a1, a2) r (a1', a2')

(PersistEntity v, Constructor c, PersistField (Key v BackendSpecific)) => Projection (AutoKeyField v c) (RestrictionHolder v c) (Key v BackendSpecific)

(Projection a1 r a1', Projection a2 r a2', Projection a3 r a3') => Projection (a1, a2, a3) r (a1', a2', a3')

(PersistEntity v, Constructor c, PersistField a) => Projection (SubField v c a) (RestrictionHolder v c) a

(PersistEntity v, Constructor c, PersistField a) => Projection (Field v c a) (RestrictionHolder v c) a

(Projection a1 r a1', Projection a2 r a2', Projection a3 r a3', Projection a4 r a4') => Projection (a1, a2, a3, a4) r (a1', a2', a3', a4')

(Projection a1 r a1', Projection a2 r a2', Projection a3 r a3', Projection a4 r a4', Projection a5 r a5') => Projection (a1, a2, a3, a4, a5) r (a1', a2', a3', a4', a5')

data RestrictionHolder v c

Instances

(PersistEntity v, Constructor c) => Projection (c (ConstructorMarker v)) (RestrictionHolder v c) v

(PersistEntity v, Constructor c, PersistField (Key v BackendSpecific)) => Projection (AutoKeyField v c) (RestrictionHolder v c) (Key v BackendSpecific)

(PersistEntity v, Constructor c, PersistField a) => Projection (SubField v c a) (RestrictionHolder v c) a

(PersistEntity v, Constructor c, PersistField a) => Projection (Field v c a) (RestrictionHolder v c) a

data Unique u

A holder for Unique constraints

Instances

(PersistEntity v, IsUniqueKey (Key v (Unique u)), ~ * r (RestrictionHolder v (UniqueConstr (Key v (Unique u))))) => Projection (u (UniqueMarker v)) r (Key v (Unique u))

data KeyForBackend db v

A holder for DB type in backend-specific keys

Constructors

(DbDescriptor db, PersistEntity v) => KeyForBackend (AutoKeyType db)

Instances

(SinglePersistField (KeyForBackend db v), PurePersistField (KeyForBackend db v), DbDescriptor db, PersistEntity v) => PrimitivePersistField (KeyForBackend db v)

(DbDescriptor db, PersistEntity v) => PersistField (KeyForBackend db v)

NeverNull (KeyForBackend db v)

data BackendSpecific

Key marked with this type can have value for any backend

Instances

(PersistEntity v, Constructor c, PersistField (Key v BackendSpecific)) => Projection (AutoKeyField v c) (RestrictionHolder v c) (Key v BackendSpecific)

data ConstructorMarker v a

A phantom datatype to make instance head diffirent c (ConstructorMarker, v)

Instances

(PersistEntity v, Constructor c) => Projection (c (ConstructorMarker v)) (RestrictionHolder v c) v

data UniqueMarker v a

A phantom datatype to make instance head diffirent u (UniqueMarker, v)

Instances

~ * r (HFalse, Key v (Unique u)) => ExtractValue (u (UniqueMarker v)) r

(PersistEntity v, IsUniqueKey (Key v (Unique u)), Projection (u (UniqueMarker v)) r a') => FieldLike (u (UniqueMarker v)) r a'

(PersistEntity v, Constructor c, FieldLike (u (UniqueMarker v)) (RestrictionHolder v c) a', ~ ((* -> *) -> *) c' (UniqueConstr (Key v' (Unique u))), ~ * v v', IsUniqueKey (Key v' (Unique u)), ~ ((* -> *) -> *) c c') => Expression (u (UniqueMarker v)) v' c'

(PersistEntity v, IsUniqueKey (Key v (Unique u)), ~ * r (RestrictionHolder v (UniqueConstr (Key v (Unique u))))) => Projection (u (UniqueMarker v)) r (Key v (Unique u))

data Proxy a

data HFalse

Instances

NormalizeValue' t (isPlain, r) => NormalizeValue HFalse HTrue t (isPlain, r)

NormalizeValue' t (isPlain, r) => NormalizeValue HFalse HFalse t (HFalse, r)

data HTrue

Instances

TypeEq x x HTrue

~ * r (isPlain, t) => NormalizeValue HTrue isPlain t r

NormalizeValue' t (isPlain, r) => NormalizeValue HFalse HTrue t (isPlain, r)

newtype ZT

Avoid orphan instances.

Constructors

ZT ZonedTime

Instances

Eq ZT

Ord ZT

Read ZT

Show ZT

delim :: Char

Constructing expressions

data Cond v c

Represents condition for a query.

Constructors

And (Cond v c) (Cond v c)

Or (Cond v c) (Cond v c)

Not (Cond v c)

forall a b . Compare ExprRelation (Expr v c a) (Expr v c b)

Instances

HasSelectOptions (Cond v c) v c

data ExprRelation

Constructors

Eq

Ne

Gt

Lt

Ge

Le

Instances

Show ExprRelation

data Update v c

Constructors

forall f a b . FieldLike f (RestrictionHolder v c) a => Update f (Expr v c b)

(~>) :: (PersistEntity v, Constructor c, FieldLike f (RestrictionHolder v c) a, Embedded a) => f -> Selector a a' -> SubField v c a'

Accesses fields of the embedded datatypes. For example, SomeField ==. ("abc", "def") ||. SomeField ~> Tuple2_0Selector ==. "def"

toArith :: (PersistEntity v, FieldLike f (RestrictionHolder v c) a') => f -> Arith v c a'

Convert field to an arithmetic value

class Projection f r a => FieldLike f r a | f -> r a where

Generalises data that can occur in expressions (so far there are Field and SubField).

Methods

fieldChain :: f -> FieldChain

It is used to map field to column names. It can be either a column name for a regular field of non-embedded type or a list of this field and the outer fields in reverse order. Eg, fieldChain $ SomeField ~> Tuple2_0Selector may result in Right [("val0", DbString), ("some", DbEmbedded False [dbType "", dbType True])]. Function fieldChain can be simplified to f v c a -> [(String, DbType)]. Datatype Either is used for optimisation of the common case, eg Field v c Int.

Instances

(PersistEntity v, IsUniqueKey (Key v (Unique u)), Projection (u (UniqueMarker v)) r a') => FieldLike (u (UniqueMarker v)) r a'

(PersistEntity v, Constructor c, Projection (AutoKeyField v c) r a') => FieldLike (AutoKeyField v c) r a'

(PersistEntity v, Constructor c, Projection (SubField v c a) r a') => FieldLike (SubField v c a) r a'

(PersistEntity v, Constructor c, Projection (Field v c a) r a') => FieldLike (Field v c a) r a'

newtype SubField v c a

Constructors

SubField ((String, DbType), [(String, EmbeddedDef)])

Instances

~ * r (HFalse, a) => ExtractValue (SubField v c a) r

(PersistEntity v, Constructor c, Projection (SubField v c a) r a') => FieldLike (SubField v c a) r a'

(PersistEntity v, Constructor c, PersistField a, ~ * v v', ~ ((* -> *) -> *) c c') => Expression (SubField v c a) v' c'

(PersistEntity v, Constructor c, PersistField a) => Projection (SubField v c a) (RestrictionHolder v c) a

data AutoKeyField v c where

It can be used in expressions like a regular field. Note that the constructor should be specified for the condition. For example, delete (AutoKeyField asTypeOf (undefined :: f v SomeConstructor) ==. k) or delete (AutoKeyField ==. k ||. SomeField ==. "DUPLICATE")

Constructors

AutoKeyField :: (PersistEntity v, Constructor c) => AutoKeyField v c

Instances

~ * r (HFalse, Key v BackendSpecific) => ExtractValue (AutoKeyField v c) r

(PersistEntity v, Constructor c, Projection (AutoKeyField v c) r a') => FieldLike (AutoKeyField v c) r a'

(PersistEntity v, Constructor c, PersistField (Key v' BackendSpecific), FieldLike (AutoKeyField v c) (RestrictionHolder v c) a', ~ * v v', ~ ((* -> *) -> *) c c') => Expression (AutoKeyField v c) v' c'

(PersistEntity v, Constructor c, PersistField (Key v BackendSpecific)) => Projection (AutoKeyField v c) (RestrictionHolder v c) (Key v BackendSpecific)

type FieldChain = ((String, DbType), [(String, EmbeddedDef)])

class NeverNull a

Types which when converted to PersistValue are never NULL. Consider the type Maybe (Maybe a). Now Nothing is stored as NULL, so we cannot distinguish between Just Nothing and Nothing which is a problem. The purpose of this class is to ban the inner Maybe's. Maybe this class can be removed when support for inner Maybe's appears.

Instances

NeverNull Bool

NeverNull Double

NeverNull Int

NeverNull Int64

NeverNull String

NeverNull ByteString

NeverNull Text

NeverNull TimeOfDay

NeverNull UTCTime

NeverNull Day

NeverNull (KeyForBackend db v)

NeverNull (Key v u)

class Numeric a

Constraint for use in arithmetic expressions. Num is not used to explicitly include only types supported by the library. TODO: consider replacement with Num

Instances

Numeric Double

Numeric Int

Numeric Int8

Numeric Int16

Numeric Int32

Numeric Int64

Numeric Word8

Numeric Word16

Numeric Word32

Numeric Word64

data Arith v c a

Arithmetic expressions which can include fields and literals

Constructors

Plus (Arith v c a) (Arith v c a)

Minus (Arith v c a) (Arith v c a)

Mult (Arith v c a) (Arith v c a)

Abs (Arith v c a)

forall f . FieldLike f (RestrictionHolder v c) a => ArithField f

Lit Int64

Instances

(PersistEntity v, Constructor c) => Eq (Arith v c a)

(PersistEntity v, Constructor c, Numeric a) => Num (Arith v c a)

(PersistEntity v, Constructor c) => Show (Arith v c a)

~ * r (HFalse, a) => ExtractValue (Arith v c a) r

(PersistEntity v, Constructor c, PersistField a, ~ * v v', ~ ((* -> *) -> *) c c') => Expression (Arith v c a) v' c'

data Expr v c a where

Used to uniformly represent fields, constants and arithmetic expressions. A value should be converted to Expr for usage in expressions

Constructors

ExprField :: (PersistEntity v, FieldLike f (RestrictionHolder v c) a') => f -> Expr v c f

ExprArith :: PersistEntity v => Arith v c a -> Expr v c (Arith v c a)

ExprPure :: forall v c a. PurePersistField a => a -> Expr v c a

data Order v c

Defines sort order of a result-set

Constructors

forall a f . FieldLike f (RestrictionHolder v c) a => Asc f

forall a f . FieldLike f (RestrictionHolder v c) a => Desc f

class HasSelectOptions a v c | a -> v c where

Associated Types

type HasLimit a

type HasOffset a

type HasOrder a

Methods

getSelectOptions :: a -> SelectOptions v c (HasLimit a) (HasOffset a) (HasOrder a)

Instances

HasSelectOptions (Cond v c) v c

HasSelectOptions (SelectOptions v c hasLimit hasOffset hasOrder) v c

data SelectOptions v c hasLimit hasOffset hasOrder

Constructors

SelectOptions

Fields

condOptions :: Cond v c

limitOptions :: Maybe Int

offsetOptions :: Maybe Int

orderOptions :: [Order v c]

Instances

HasSelectOptions (SelectOptions v c hasLimit hasOffset hasOrder) v c

limitTo :: (HasSelectOptions a v c, HasLimit a ~ HFalse) => a -> Int -> SelectOptions v c HTrue (HasOffset a) (HasOrder a)

offsetBy :: (HasSelectOptions a v c, HasOffset a ~ HFalse) => a -> Int -> SelectOptions v c (HasLimit a) HTrue (HasOrder a)

orderBy :: (HasSelectOptions a v c, HasOrder a ~ HFalse) => a -> [Order v c] -> SelectOptions v c (HasLimit a) (HasOffset a) HTrue

Type description

data DbType

A DB data type. Naming attempts to reflect the underlying Haskell datatypes, eg DbString instead of DbVarchar. Different databases may have different translations for these types.

Constructors

DbString

DbInt32

DbInt64

DbReal

DbBool

DbDay

DbTime

DbDayTime

DbDayTimeZoned

DbBlob

DbMaybe DbType

DbList String DbType

DbEmbedded EmbeddedDef

DbEntity (Maybe (EmbeddedDef, String)) EntityDef

Instances

Eq DbType

Show DbType

data EntityDef

Describes an ADT.

Constructors

EntityDef

Fields

entityName :: String

Entity name. entityName (entityDef v) == persistName v

typeParams :: [DbType]

Named types of the instantiated polymorphic type parameters

constructors :: [ConstructorDef]

List of entity constructors definitions

Instances

Eq EntityDef

Show EntityDef

data EmbeddedDef

The first argument is a flag which defines if the field names should be concatenated with the outer field name (False) or used as is which provides full control over table column names (True). Value False should be the default value so that a datatype can be embedded without name conflict concern. The second argument list of field names and field types.

Constructors

EmbeddedDef Bool [(String, DbType)]

Instances

Eq EmbeddedDef

Show EmbeddedDef

data ConstructorDef

Describes an entity constructor

Constructors

ConstructorDef

Fields

constrNum :: Int

Number of the constructor in the ADT

constrName :: String

Constructor name

constrAutoKeyName :: Maybe String

Autokey name if any

constrParams :: [(String, DbType)]

Parameter names with their named type

constrUniques :: [UniqueDef]

Uniqueness constraints on the constructor fiels

Instances

Eq ConstructorDef

Show ConstructorDef

class Constructor c where

Phantom constructors are made instances of this class. This class should be used only by Template Haskell codegen

Methods

phantomConstrName :: c (a :: * -> *) -> String

phantomConstrNum :: c (a :: * -> *) -> Int

class (Constructor (UniqueConstr uKey), PurePersistField uKey) => IsUniqueKey uKey where

Associated Types

type UniqueConstr uKey :: (* -> *) -> *

Methods

extractUnique :: uKey ~ Key v u => v -> uKey

uniqueNum :: uKey -> Int

data UniqueDef

Unique name and list of the field names that form a unique combination. Only fields of PrimitivePersistField types can be used in a unique definition

Constructors

UniqueDef

Fields

uniqueName :: String

uniqueFields :: [(String, DbType)]

Instances

Eq UniqueDef

Show UniqueDef

Migration

type SingleMigration = Either [String] [(Bool, Int, String)]

Either error messages or migration queries with safety flag and execution order

type NamedMigrations = Map String SingleMigration

Datatype names and corresponding migrations

type Migration m = StateT NamedMigrations m ()

Database

class (Monad m, DbDescriptor (PhantomDb m)) => PersistBackend m where

Associated Types

type PhantomDb m

A token which defines the DB type. For example, different monads working with Sqlite, return Sqlite type.

Methods

insert :: PersistEntity v => v -> m (AutoKey v)

Insert a new record to a database and return its Key

insertBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u))) => u (UniqueMarker v) -> v -> m (Either (AutoKey v) (AutoKey v))

Try to insert a record and return Right newkey. If there is a constraint violation for the given constraint, Left oldkey is returned , where oldkey is an identifier of the record with the matching values.

insertByAll :: PersistEntity v => v -> m (Either (AutoKey v) (AutoKey v))

Try to insert a record and return Right newkey. If there is a constraint violation for any constraint, Left oldkey is returned , where oldkey is an identifier of the record with the matching values. Note that if several constraints are violated, a key of an arbitrary matching record is returned.

replace :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific)) => Key v BackendSpecific -> v -> m ()

Replace a record with the given autogenerated key. Result is undefined if the record does not exist.

select :: (PersistEntity v, Constructor c, HasSelectOptions opts v c) => opts -> m [v]

Return a list of the records satisfying the condition

selectAll :: PersistEntity v => m [(AutoKey v, v)]

Return a list of all records. Order is undefined. It is useful for datatypes with multiple constructors.

get :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific)) => Key v BackendSpecific -> m (Maybe v)

Fetch an entity from a database

getBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u))) => Key v (Unique u) -> m (Maybe v)

Fetch an entity from a database by its unique key

update :: (PersistEntity v, Constructor c) => [Update v c] -> Cond v c -> m ()

Update the records satisfying the condition

delete :: (PersistEntity v, Constructor c) => Cond v c -> m ()

Remove the records satisfying the condition

deleteByKey :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific)) => Key v BackendSpecific -> m ()

Remove the record with given key. No-op if the record does not exist

count :: (PersistEntity v, Constructor c) => Cond v c -> m Int

Count total number of records satisfying the condition

countAll :: PersistEntity v => v -> m Int

Count total number of records with all constructors

project :: (PersistEntity v, Constructor c, Projection p (RestrictionHolder v c) a', HasSelectOptions opts v c) => p -> opts -> m [a']

Fetch projection of some fields

migrate :: PersistEntity v => v -> Migration m

Check database schema and create migrations for the entity and the entities it contains

executeRaw

Arguments

:: Bool

keep in cache

-> String

query

-> [PersistValue]

positional parameters

-> m ()

Execute raw query

queryRaw

Arguments

:: Bool

keep in cache

-> String

query

-> [PersistValue]

positional parameters

-> (RowPopper m -> m a)

results processing function

-> m a

Execute raw query with results

insertList :: PersistField a => [a] -> m Int64

getList :: PersistField a => Int64 -> m [a]

class PrimitivePersistField (AutoKeyType a) => DbDescriptor a

Associated Types

type AutoKeyType a

Type of the database default autoincremented key. For example, Sqlite has Int64

type RowPopper m = m (Maybe [PersistValue])

newtype Monad m => DbPersist conn m a

Constructors

DbPersist

Fields

unDbPersist :: ReaderT conn m a

Instances

(Applicative IO, Applicative (DbPersist conn m), Monad IO, Monad (DbPersist conn m), MonadBase IO m) => MonadBase IO (DbPersist conn m)

(MonadBase IO (DbPersist conn m), MonadBaseControl IO m) => MonadBaseControl IO (DbPersist conn m)

MonadTrans (DbPersist conn)

MonadTrans (DbPersist conn) => MonadTransControl (DbPersist conn)

Monad m => Monad (DbPersist conn m)

Functor m => Functor (DbPersist conn m)

(Functor (DbPersist conn m), Applicative m) => Applicative (DbPersist conn m)

(Monad (DbPersist conn m), MonadIO m) => MonadIO (DbPersist conn m)

runDbPersist :: Monad m => DbPersist conn m a -> conn -> m a