Database.PostgreSQL.Store.Table

Documentation

data TableDescription

Description of a table type

Constructors

TableDescription

Fields

tableName :: String

Table name

tableIdentifier :: String

Identifier column name

Instances

Eq TableDescription

Ord TableDescription

Show TableDescription

class DescribableTable a => Table a where

Methods

insert :: a -> Errand (Reference a)

Insert a row into the table and return a Reference to the inserted row.

find :: HasID i => i a -> Errand (Row a)

Find the row identified by the given reference.

update :: HasID i => i a -> a -> Errand ()

Update an existing row.

delete :: HasID i => i a -> Errand ()

Delete a row from the table.

createQuery :: Proxy a -> Query

Generate the query which creates this table inside the database. Use mkCreateQuery for convenience.

tableResultProcessor :: ResultProcessor [Row a]

Extract rows from a result set.

tableRefResultProcessor :: ResultProcessor [Reference a]

Extract only a Reference to each row.

data Row a

Resolved row

Constructors

Row

Fields

rowID :: !Int64

Identifier

rowValue :: !a

Value

Instances

HasID Row

Eq a => Eq (Row a)

Ord a => Ord (Row a)

Show a => Show (Row a)

Table a => Result (Row a)

newtype Reference a

Reference to a row

Constructors

Reference Int64

Instances

HasID Reference

Eq (Reference a)

Ord (Reference a)

Show (Reference a)

Table a => Column (Reference a)

Table a => Result (Reference a)

class HasID a where

A value of that type contains an ID.

Methods

referenceID :: a b -> Int64

Retrieve the underlying ID.

Instances

HasID Reference

HasID Row

data TableConstraint

Options to mkTable.

Constructors

Unique [Name]

A combination of fields must be unique. Unique ['name1, 'name2, ...] works analogous to the following table constraint: UNIQUE (name1, name2, ...)

ForeignKey [Name] Name [Name]

A combination of fields references another combination of fields from a different table. ForeignKey ['name1, 'name2, ...] ''RefTable ['refname1, 'refname2, ...] works like this table constraint in SQL: FOREIGN KEY (name1, name2, ...) REFERENCES RefTable(refname1, refname2, ...)

Instances

Eq TableConstraint

Ord TableConstraint

Show TableConstraint

mkTable :: Name -> [TableConstraint] -> Q [Dec]

Implement Table for a data type. The given type must fulfill these requirements:

• Data type
• No type context
• No type variables
• One record constructor with 1 or more fields
• All field types must have an instance of Column

Example:

{-# LANGUAGE TemplateHaskell #-}
module Movies where

...

data Movie = Movie {
    movieTitle :: String,
    movieYear  :: Int
} deriving Show

mkTable ''Movie []

data Actor = Actor {
    actorName :: String,
    actorAge  :: Int
} deriving Show

mkTable ''Actor []

data MovieCast = MovieCast {
    movieCastMovie :: Reference Movie,
    movieCastActor :: Reference Actor
} deriving Show

mkTable ''MovieCast []

mkCreateQuery :: Name -> Q Exp

Generate a Query which will create the table described my the given type.

Example:

data Table = Table { myField :: Int }
mkTable ''Table []
...
query_ $(mkCreateQuery ''Table)