generic-persistence-0.5.0: Database persistence using generics
Safe HaskellSafe-Inferred
LanguageGHC2021

Database.GP.GenericPersistence

Synopsis

Documentation

selectById :: forall a id. (Entity a, Convertible id SqlValue) => Conn -> id -> IO (Maybe a) Source #

This module defines RDBMS Persistence operations for Record Data Types that are instances of Data. I call instances of such a data type Entities.

The Persistence operations are using Haskell generics to provide compile time reflection capabilities. HDBC is used to access the RDBMS.

A function that retrieves an entity from a database. The function takes entity id as parameter. If an entity with the given id exists in the database, it is returned as a Just value. If no such entity exists, Nothing is returned. An error is thrown if there are more than one entity with the given id.

select :: forall a. Entity a => Conn -> WhereClauseExpr -> IO [a] Source #

This function retrieves all entities of type a from a database. The function takes an HDBC connection as parameter. The type a is determined by the context of the function call. retrieveAll :: forall a. (Entity a) => Conn -> IO [a] retrieveAll conn = do eitherExRow <- GpSafe.retrieveAll @a conn case eitherExRow of Left ex -> throw ex Right rows -> pure rows

This function retrieves all entities of type a that match some query criteria. The function takes an HDBC connection and a WhereClauseExpr as parameters. The type a is determined by the context of the function call. The function returns a (possibly empty) list of all matching entities. The WhereClauseExpr is typically constructed using any tiny query dsl based on infix operators.

entitiesFromRows :: forall a. Entity a => Conn -> [[SqlValue]] -> IO [a] Source #

A function that constructs a list of entities from a list of rows. The function takes an HDBC connection and a list of rows as parameters. The type a is determined by the context of the function call. The function returns a list of entities. This can be useful if you want to use your own SQL queries.

persist :: forall a. Entity a => Conn -> a -> IO () Source #

A function that persists an entity to a database. The function takes an HDBC connection and an entity as parameters. The entity is either inserted or updated, depending on whether it already exists in the database. The required SQL statements are generated dynamically using Haskell generics and reflection

insert :: forall a. Entity a => Conn -> a -> IO () Source #

A function that explicitely inserts an entity into a database.

insertReturning :: forall a. Entity a => Conn -> a -> IO a Source #

insertMany :: forall a. Entity a => Conn -> [a] -> IO () Source #

A function that inserts a list of entities into a database. The function takes an HDBC connection and a list of entities as parameters. The insert-statement is compiled only once and then executed for each entity.

update :: forall a. Entity a => Conn -> a -> IO () Source #

A function that explicitely updates an entity in a database.

updateMany :: forall a. Entity a => Conn -> [a] -> IO () Source #

A function that updates a list of entities in a database. The function takes an HDBC connection and a list of entities as parameters. The update-statement is compiled only once and then executed for each entity.

delete :: forall a. Entity a => Conn -> a -> IO () Source #

A function that deletes an entity from a database. The function takes an HDBC connection and an entity as parameters.

deleteMany :: forall a. Entity a => Conn -> [a] -> IO () Source #

A function that deletes a list of entities from a database. The function takes an HDBC connection and a list of entities as parameters. The delete-statement is compiled only once and then executed for each entity.

setupTableFor :: forall a. Entity a => Database -> Conn -> IO () Source #

set up a table for a given entity type. The table is dropped (if existing) and recreated. The function takes an HDBC connection as parameter.

data Conn Source #

This module defines a wrapper around an HDBC IConnection. Using this wrapper Conn simplifies the signature of the functions in the GP module. It allows to use any HDBC connection without having to define a new function for each connection type. It also provides additional attributes to the connection, like the database type and the implicit commit flag. These attributes can be used to implement database specific functionality, modify transaction behaviour, etc.

This code has been inspired by the HDBC ConnectionWrapper and some parts have been copied verbatim from the HDBC Database.HDBC.Types module.

This module also defines a ConnectionPool type, which provides basic connection pooling functionality.

A wrapper around an HDBC IConnection.

Constructors

forall conn.IConnection conn => Conn 

Fields

  • implicitCommit :: Bool

    If True, the GenericPersistence functions will commit the transaction after each operation.

  • connection :: conn

    The wrapped connection

Instances

Instances details
IConnection Conn Source #

manually implement the IConnection type class for the Conn type.

Instance details

Defined in Database.GP.Conn

connect :: forall conn. IConnection conn => TxHandling -> conn -> Conn Source #

a smart constructor for the Conn type.

data Database Source #

An enumeration of the supported database types.

Constructors

Postgres 
SQLite 

Instances

Instances details
Show Database Source #

Oracle | MSSQL | MySQL

Instance details

Defined in Database.GP.SqlGenerator

Eq Database Source # 
Instance details

Defined in Database.GP.SqlGenerator

type ConnectionPool = Pool Conn Source #

A pool of connections.

createConnPool Source #

Arguments

:: IConnection conn 
=> TxHandling

the transaction mode

-> String

the connection string

-> (String -> IO conn)

a function that takes a connection string and returns an IConnection

-> Double

the time (in seconds) to keep idle connections open

-> Int

the maximum number of connections to keep open

-> IO ConnectionPool

the resulting connection pool

Creates a connection pool.

withResource :: Pool a -> (a -> IO r) -> IO r #

Take a resource from the pool, perform an action with it and return it to the pool afterwards.

  • If the pool has an idle resource available, it is used immediately.
  • Otherwise, if the maximum number of resources has not yet been reached, a new resource is created and used.
  • If the maximum number of resources has been reached, this function blocks until a resource becomes available.

If the action throws an exception of any type, the resource is destroyed and not returned to the pool.

It probably goes without saying that you should never manually destroy a pooled resource, as doing so will almost certainly cause a subsequent user (who expects the resource to be valid) to throw an exception.

class (Generic a, HasConstructor (Rep a), HasSelectors (Rep a)) => Entity a where Source #

This is the Entity class. It is a type class that is used to define the mapping between a Haskell product type in record notation and a database table. The class has a default implementation for all methods. The default implementation uses the type information to determine a simple 1:1 mapping.

That means that - the type name is used as the table name and the - field names are used as the column names. - A field named 'typeNameID' is used as the primary key field.

The default implementation can be overridden by defining a custom instance for a type.

Please note the following constraints, which apply to all valid Entity type, but that are not explicitely encoded in the type class definition:

  • The type must be a product type in record notation.
  • The type must have exactly one constructor.
  • There must be single primary key field, compund primary keys are not supported.

Minimal complete definition

Nothing

Methods

fromRow :: Conn -> [SqlValue] -> IO a Source #

Converts a database row to a value of type a.

default fromRow :: GFromRow (Rep a) => Conn -> [SqlValue] -> IO a Source #

toRow :: Conn -> a -> IO [SqlValue] Source #

Converts a value of type a to a database row.

default toRow :: GToRow (Rep a) => Conn -> a -> IO [SqlValue] Source #

idField :: String Source #

Returns the name of the primary key field for a type a.

default idField :: String Source #

fieldsToColumns :: [(String, String)] Source #

Returns a list of tuples that map field names to column names for a type a.

tableName :: String Source #

Returns the name of the table for a type a.

class GToRow f Source #

Minimal complete definition

gtoRow

Instances

Instances details
(GToRow a, GToRow b) => GToRow (a :*: b :: k -> Type) Source # 
Instance details

Defined in Database.GP.Entity

Methods

gtoRow :: forall (a0 :: k0). (a :*: b) a0 -> [SqlValue] Source #

Convertible a SqlValue => GToRow (K1 i a :: k -> Type) Source # 
Instance details

Defined in Database.GP.Entity

Methods

gtoRow :: forall (a0 :: k0). K1 i a a0 -> [SqlValue] Source #

GToRow a => GToRow (M1 i c a :: k -> Type) Source # 
Instance details

Defined in Database.GP.Entity

Methods

gtoRow :: forall (a0 :: k0). M1 i c a a0 -> [SqlValue] Source #

class GFromRow f Source #

Minimal complete definition

gfromRow

Instances

Instances details
(KnownNat (NumFields f), GFromRow f, GFromRow g) => GFromRow (f :*: g :: Type -> Type) Source #

This instance is the most interesting one. It splits the list of SqlValues into two parts, one for the first field and one for the rest. Then it uses the GFromRow instance for the first field to convert the first part of the list and the GFromRow instance for the rest of the fields to convert the second part of the list. Finally, it combines the two results using the :*: constructor. https://stackoverflow.com/questions/75485429/how-to-use-ghc-generics-to-convert-from-product-data-types-to-a-list-of-sqlvalue/75485650#75485650

Instance details

Defined in Database.GP.Entity

Methods

gfromRow :: forall (a :: k). [SqlValue] -> (f :*: g) a

Convertible SqlValue a => GFromRow (K1 i a :: k -> Type) Source # 
Instance details

Defined in Database.GP.Entity

Methods

gfromRow :: forall (a0 :: k0). [SqlValue] -> K1 i a a0

GFromRow a => GFromRow (M1 i c a :: k -> Type) Source # 
Instance details

Defined in Database.GP.Entity

Methods

gfromRow :: forall (a0 :: k0). [SqlValue] -> M1 i c a a0

columnNameFor :: forall a. Entity a => String -> String Source #

A convenience function: returns the name of the column for a field of a type a.

data TypeInfo a Source #

A data type holding meta-data about a type. The Phantom type parameter a ensures type safety for reflective functions that use this type to create type instances.

typeInfo :: forall a. (HasConstructor (Rep a), HasSelectors (Rep a), Generic a) => TypeInfo a Source #

this function is a smart constructor for TypeInfo objects. It takes a value of type a and returns a `TypeInfo a` object. If the type has no named fields, an error is thrown. If the type has more than one constructor, an error is thrown.

data PersistenceException Source #

This is the "safe" version of the module Database.GP.GenericPersistence. It uses Either to return errors.

This module defines RDBMS Persistence operations for Record Data Types that are instances of Data. I call instances of such a data type Entities.

The Persistence operations are using Haskell generics to provide compile time reflection capabilities. HDBC is used to access the RDBMS.

exceptions that may occur during persistence operations

in' :: Convertible b SqlValue => Field -> [b] -> WhereClauseExpr infixl 4 Source #

data SortOrder Source #

Constructors

ASC 
DESC 

Instances

Instances details
Show SortOrder Source # 
Instance details

Defined in Database.GP.Query

data NonEmpty a #

Non-empty (and non-strict) list type.

Since: base-4.9.0.0

Constructors

a :| [a] infixr 5 

Instances

Instances details
Foldable NonEmpty

Since: base-4.9.0.0

Instance details

Defined in Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m #

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m #

foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m #

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b #

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b #

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b #

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b #

foldr1 :: (a -> a -> a) -> NonEmpty a -> a #

foldl1 :: (a -> a -> a) -> NonEmpty a -> a #

toList :: NonEmpty a -> [a] #

null :: NonEmpty a -> Bool #

length :: NonEmpty a -> Int #

elem :: Eq a => a -> NonEmpty a -> Bool #

maximum :: Ord a => NonEmpty a -> a #

minimum :: Ord a => NonEmpty a -> a #

sum :: Num a => NonEmpty a -> a #

product :: Num a => NonEmpty a -> a #

Traversable NonEmpty

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) #

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) #

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) #

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #

Applicative NonEmpty

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a #

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b #

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c #

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #

Functor NonEmpty

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

fmap :: (a -> b) -> NonEmpty a -> NonEmpty b #

(<$) :: a -> NonEmpty b -> NonEmpty a #

Monad NonEmpty

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b #

(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #

return :: a -> NonEmpty a #

Generic1 NonEmpty 
Instance details

Defined in GHC.Generics

Associated Types

type Rep1 NonEmpty :: k -> Type #

Methods

from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a #

to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a #

Semigroup (NonEmpty a)

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

(<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a #

sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a #

stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #

Generic (NonEmpty a) 
Instance details

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type #

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x #

to :: Rep (NonEmpty a) x -> NonEmpty a #

Read a => Read (NonEmpty a)

Since: base-4.11.0.0

Instance details

Defined in GHC.Read

Show a => Show (NonEmpty a)

Since: base-4.11.0.0

Instance details

Defined in GHC.Show

Methods

showsPrec :: Int -> NonEmpty a -> ShowS #

show :: NonEmpty a -> String #

showList :: [NonEmpty a] -> ShowS #

Eq a => Eq (NonEmpty a)

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

(==) :: NonEmpty a -> NonEmpty a -> Bool #

(/=) :: NonEmpty a -> NonEmpty a -> Bool #

Ord a => Ord (NonEmpty a)

Since: base-4.9.0.0

Instance details

Defined in GHC.Base

Methods

compare :: NonEmpty a -> NonEmpty a -> Ordering #

(<) :: NonEmpty a -> NonEmpty a -> Bool #

(<=) :: NonEmpty a -> NonEmpty a -> Bool #

(>) :: NonEmpty a -> NonEmpty a -> Bool #

(>=) :: NonEmpty a -> NonEmpty a -> Bool #

max :: NonEmpty a -> NonEmpty a -> NonEmpty a #

min :: NonEmpty a -> NonEmpty a -> NonEmpty a #

type Rep1 NonEmpty

Since: base-4.6.0.0

Instance details

Defined in GHC.Generics

type Rep (NonEmpty a)

Since: base-4.6.0.0

Instance details

Defined in GHC.Generics