Database.Groundhog.Generic

This helper module is intended for use by the backend creators

Migration

createMigration :: Monad m => Migration m -> m NamedMigrations

Produce the migrations but not execute them. Fails when an unsafe migration occurs.

executeMigration :: (PersistBackend m, MonadIO m) => NamedMigrations -> m ()

Execute the migrations with printing to stderr. Fails when an unsafe migration occurs.

executeMigrationSilent :: (PersistBackend m, MonadIO m) => NamedMigrations -> m ()

Execute the migrations. Fails when an unsafe migration occurs.

executeMigrationUnsafe :: (PersistBackend m, MonadIO m) => NamedMigrations -> m ()

Execute migrations. Executes the unsafe migrations without warnings and prints them to stderr

runMigration :: (PersistBackend m, MonadIO m) => Migration m -> m ()

Creates migrations and executes them with printing to stderr. Fails when an unsafe migration occurs. > runMigration m = createMigration m >>= executeMigration

runMigrationSilent :: (PersistBackend m, MonadIO m) => Migration m -> m ()

Creates migrations and silently executes them. Fails when an unsafe migration occurs. > runMigration m = createMigration m >>= executeMigrationSilent

runMigrationUnsafe :: (PersistBackend m, MonadIO m) => Migration m -> m ()

Creates migrations and executes them with printing to stderr. Executes the unsafe migrations without warnings > runMigrationUnsafe m = createMigration m >>= executeMigrationUnsafe

getQueries

Arguments

:: Bool

True - support unsafe queries

-> SingleMigration

-> Either [String] [String]

Returns either a list of errors in migration or a list of queries

printMigration :: MonadIO m => NamedMigrations -> m ()

Pretty print the migrations

mergeMigrations :: [SingleMigration] -> SingleMigration

Joins the migrations. The result is either all error messages or all queries

Helpers for running Groundhog actions

class (MonadIO m, MonadLogger m, MonadBaseControl IO m, MonadReader cm m, ConnectionManager cm conn) => HasConn m cm conn

This class helps to shorten the type signatures of user monadic code.

Instances

(MonadIO m, MonadLogger m, MonadBaseControl IO m, MonadReader cm m, ConnectionManager cm conn) => HasConn m cm conn

runDb :: HasConn m cm conn => DbPersist conn m a -> m a

It helps to run database operations within an application monad.

runDbConn :: (MonadBaseControl IO m, MonadIO m, ConnectionManager cm conn) => DbPersist conn (NoLoggingT m) a -> cm -> m a

Runs action within connection. It can handle a simple connection, a pool of them, etc.

runDbConnNoTransaction :: (MonadBaseControl IO m, MonadIO m, ConnectionManager cm conn) => DbPersist conn (NoLoggingT m) a -> cm -> m a

It is similar to runDbConn but runs action without transaction. It can be useful if you use Groundhog within IO monad or in other cases when you cannot put PersistBackend instance into your monad stack.

flip withConn cm $ \conn -> liftIO $ do
  -- transaction is already opened by withConn at this point
  someIOAction
  getValuesFromIO $ \value -> runDbConnNoTransaction (insert_ value) conn

withSavepoint :: (HasConn m cm conn, SingleConnectionManager cm conn, Savepoint conn) => String -> m a -> m a

It helps to run withConnSavepoint within a monad.

Helper functions for defining *PersistValue instances

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

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

primToPurePersistValues :: (DbDescriptor db, PrimitivePersistField a) => proxy db -> a -> [PersistValue] -> [PersistValue]

primFromPurePersistValues :: (DbDescriptor db, PrimitivePersistField a) => proxy db -> [PersistValue] -> (a, [PersistValue])

primToSinglePersistValue :: (PersistBackend m, PrimitivePersistField a) => a -> m PersistValue

primFromSinglePersistValue :: (PersistBackend m, PrimitivePersistField a) => PersistValue -> m a

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

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

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

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

toSinglePersistValueUnique :: forall m v u. (PersistBackend m, PersistEntity v, IsUniqueKey (Key v (Unique u)), PrimitivePersistField (Key v (Unique u))) => u (UniqueMarker v) -> v -> m PersistValue

fromSinglePersistValueUnique :: forall m v u. (PersistBackend m, PersistEntity v, IsUniqueKey (Key v (Unique u)), PrimitivePersistField (Key v (Unique u))) => u (UniqueMarker v) -> PersistValue -> m v

toPersistValuesUnique :: forall m v u. (PersistBackend m, PersistEntity v, IsUniqueKey (Key v (Unique u))) => u (UniqueMarker v) -> v -> m ([PersistValue] -> [PersistValue])

fromPersistValuesUnique :: forall m v u. (PersistBackend m, PersistEntity v, IsUniqueKey (Key v (Unique u))) => u (UniqueMarker v) -> [PersistValue] -> m (v, [PersistValue])

toSinglePersistValueAutoKey :: forall m v. (PersistBackend m, PersistEntity v, PrimitivePersistField (AutoKey v)) => v -> m PersistValue

fromSinglePersistValueAutoKey :: forall m v. (PersistBackend m, PersistEntity v, PrimitivePersistField (Key v BackendSpecific)) => PersistValue -> m v

failMessage :: PersistField a => a -> [PersistValue] -> String

failMessageNamed :: String -> [PersistValue] -> String

Other

bracket

Arguments

:: MonadBaseControl IO m

=> m a

computation to run first ("acquire resource")

-> (a -> m b)

computation to run last ("release resource")

-> (a -> m c)

computation to run in-between

-> m c

finally

Arguments

:: MonadBaseControl IO m

=> m a

computation to run first

-> m b

computation to run afterward (even if an exception was raised)

-> m a

onException :: MonadBaseControl IO m => m a -> m b -> m a

data PSFieldDef str

Constructors

PSFieldDef

Fields

psFieldName :: str

psDbFieldName :: Maybe str

psDbTypeName :: Maybe str

psExprName :: Maybe str

psEmbeddedDef :: Maybe [PSFieldDef str]

psDefaultValue :: Maybe str

psReferenceParent :: Maybe (Maybe ((Maybe str, str), [str]), Maybe ReferenceActionType, Maybe ReferenceActionType)

Instances

Eq str => Eq (PSFieldDef str)

Show str => Show (PSFieldDef str)

applyDbTypeSettings :: PSFieldDef String -> DbType -> DbType

findOne :: (Eq x, Show x) => String -> (a -> x) -> x -> [a] -> a

replaceOne :: (Eq x, Show x) => String -> (a -> x) -> (b -> x) -> (a -> b -> b) -> a -> [b] -> [b]

matchElements :: Show a => (a -> b -> Bool) -> [a] -> [b] -> ([a], [b], [(a, b)])

Returns only old elements, only new elements, and matched pairs (old, new). The new ones exist only in datatype, the old are present only in DB, match is typically by name (the properties of the matched elements may differ).

haveSameElems :: Show a => (a -> b -> Bool) -> [a] -> [b] -> Bool

mapAllRows :: Monad m => ([PersistValue] -> m a) -> RowPopper m -> m [a]

phantomDb :: PersistBackend m => m (proxy (PhantomDb m))

getAutoKeyType :: DbDescriptor db => proxy db -> DbTypePrimitive

getUniqueFields :: UniqueDef' str (Either field str) -> [field]

isSimple :: [ConstructorDef] -> Bool

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

Deprecated: Use deleteBy instead