| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Database.GP.Entity
Synopsis
- class (Generic a, HasConstructor (Rep a), HasSelectors (Rep a)) => Entity a where
- columnNameFor :: forall a. Entity a => String -> String
- gtoRow :: GToRow f => f a -> [SqlValue]
- class GToRow f
- class GFromRow f
- maybeFieldTypeFor :: forall a. Entity a => String -> Maybe TypeRep
- data Conn = forall conn.IConnection conn => Conn {
- implicitCommit :: Bool
- connection :: conn
- data TxHandling
- maybeIdFieldIndex :: forall a. Entity a => Maybe Int
- fieldIndex :: forall a. Entity a => String -> Int
Documentation
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.
toRow :: Conn -> a -> IO [SqlValue] Source #
Converts a value of type a to a database row.
Returns the name of the primary key field for a type a.
fieldsToColumns :: [(String, String)] Source #
Returns a list of tuples that map field names to column names for a type a.
default fieldsToColumns :: [(String, String)] Source #
Returns the name of the table for a type a.
autoIncrement :: Bool Source #
Returns True if the primary key field for a type a is autoincremented by the database.
default autoIncrement :: Bool Source #
columnNameFor :: forall a. Entity a => String -> String Source #
A convenience function: returns the name of the column for a field of a type a.
Minimal complete definition
Minimal complete definition
gfromRow
Instances
| (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
|
Defined in Database.GP.Entity | |
| Convertible SqlValue a => GFromRow (K1 i a :: k -> Type) Source # | |
Defined in Database.GP.Entity | |
| GFromRow a => GFromRow (M1 i c a :: k -> Type) Source # | |
Defined in Database.GP.Entity | |
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
| |
Instances
| IConnection Conn Source # | manually implement the IConnection type class for the Conn type. |
Defined in Database.GP.Conn Methods disconnect :: Conn -> IO () # runRaw :: Conn -> String -> IO () # run :: Conn -> String -> [SqlValue] -> IO Integer # prepare :: Conn -> String -> IO Statement # hdbcDriverName :: Conn -> String # hdbcClientVer :: Conn -> String # proxiedClientName :: Conn -> String # proxiedClientVer :: Conn -> String # dbServerVer :: Conn -> String # dbTransactionSupport :: Conn -> Bool # getTables :: Conn -> IO [String] # describeTable :: Conn -> String -> IO [(String, SqlColDesc)] # | |
data TxHandling Source #
Constructors
| AutoCommit | |
| ExplicitCommit |
maybeIdFieldIndex :: forall a. Entity a => Maybe Int Source #
Returns Just index of the primary key field for a type a.
if the type has no primary key field, Nothing is returned.
fieldIndex :: forall a. Entity a => String -> Int Source #
returns the index of a field of an entity. The index is the position of the field in the list of fields of the entity. If no such field exists, an error is thrown. The function takes an field name as parameters, the type of the entity is determined by the context.