Database.PostgreSQL.Store

Errands

data Errand a

An interaction with the database

Instances

Monad Errand

Methods

(>>=) :: Errand a -> (a -> Errand b) -> Errand b

(>>) :: Errand a -> Errand b -> Errand b

return :: a -> Errand a

fail :: String -> Errand a

Functor Errand

Methods

fmap :: (a -> b) -> Errand a -> Errand b

(<$) :: a -> Errand b -> Errand a

Applicative Errand

Methods

pure :: a -> Errand a

(<*>) :: Errand (a -> b) -> Errand a -> Errand b

(*>) :: Errand a -> Errand b -> Errand b

(<*) :: Errand a -> Errand b -> Errand a

MonadIO Errand

Methods

liftIO :: IO a -> Errand a

MonadError ErrandError Errand

Methods

throwError :: ErrandError -> Errand a

catchError :: Errand a -> (ErrandError -> Errand a) -> Errand a

data ErrandError

Error during errand

Constructors

NoResult

No Result has been returned.

EmptyResult

Result set is empty.

UserError String

A user has thrown an error.

ExecError ExecStatus ErrorCode ByteString ByteString ByteString

Query execution failed.

ResultError ResultError

Result processing failed.

Instances

Eq ErrandError

Methods

(==) :: ErrandError -> ErrandError -> Bool

(/=) :: ErrandError -> ErrandError -> Bool

Show ErrandError

Methods

showsPrec :: Int -> ErrandError -> ShowS

show :: ErrandError -> String

showList :: [ErrandError] -> ShowS

MonadError ErrandError Errand

Methods

throwError :: ErrandError -> Errand a

catchError :: Errand a -> (ErrandError -> Errand a) -> Errand a

data ErrorCode

Error codes

Constructors

UnknownErrorCause ByteString

IntegrityViolation

RestrictViolation

NotNullViolation

ForeignKeyViolation

UniqueViolation

CheckViolation

ExclusionViolation

Instances

Eq ErrorCode

Methods

(==) :: ErrorCode -> ErrorCode -> Bool

(/=) :: ErrorCode -> ErrorCode -> Bool

Show ErrorCode

Methods

showsPrec :: Int -> ErrorCode -> ShowS

show :: ErrorCode -> String

showList :: [ErrorCode] -> ShowS

data ExecStatus :: *

Constructors

EmptyQuery

The string sent to the server was empty.

CommandOk

Successful completion of a command returning no data.

TuplesOk

Successful completion of a command returning data (such as a SELECT or SHOW).

CopyOut

Copy Out (from server) data transfer started.

CopyIn

Copy In (to server) data transfer started.

BadResponse

The server's response was not understood.

NonfatalError

A nonfatal error (a notice or warning) occurred.

FatalError

A fatal error occurred.

SingleTuple

The PGresult contains a single result tuple from the current command. This status occurs only when single-row mode has been selected for the query.

Instances

Enum ExecStatus

Methods

succ :: ExecStatus -> ExecStatus

pred :: ExecStatus -> ExecStatus

toEnum :: Int -> ExecStatus

fromEnum :: ExecStatus -> Int

enumFrom :: ExecStatus -> [ExecStatus]

enumFromThen :: ExecStatus -> ExecStatus -> [ExecStatus]

enumFromTo :: ExecStatus -> ExecStatus -> [ExecStatus]

enumFromThenTo :: ExecStatus -> ExecStatus -> ExecStatus -> [ExecStatus]

Eq ExecStatus

Methods

(==) :: ExecStatus -> ExecStatus -> Bool

(/=) :: ExecStatus -> ExecStatus -> Bool

Show ExecStatus

Methods

showsPrec :: Int -> ExecStatus -> ShowS

show :: ExecStatus -> String

showList :: [ExecStatus] -> ShowS

runErrand :: Connection -> Errand a -> IO (Either ErrandError a)

Run an errand.

execute :: Query -> Errand Result

Execute a query and return the internal raw result.

query :: Result a => Query -> Errand [a]

Execute a query and process its result set.

query_ :: Query -> Errand ()

Execute a query and dismiss its result.

queryWith :: Query -> ResultProcessor a -> Errand [a]

Execute a query and process its result set using the provided result processor.

Queries

data Query

Query including statement and parameters

Use the pgsq quasi-quoter to conveniently create queries.

Constructors

Query

Fields

• queryStatement :: !ByteString

  Statement

• queryParams :: ![Value]

  Parameters

Instances

Eq Query

Methods

(==) :: Query -> Query -> Bool

(/=) :: Query -> Query -> Bool

Ord Query

Methods

compare :: Query -> Query -> Ordering

(<) :: Query -> Query -> Bool

(<=) :: Query -> Query -> Bool

(>) :: Query -> Query -> Bool

(>=) :: Query -> Query -> Bool

max :: Query -> Query -> Query

min :: Query -> Query -> Query

Show Query

Methods

showsPrec :: Int -> Query -> ShowS

show :: Query -> String

showList :: [Query] -> ShowS

QueryBuildable ByteString Value Query

Methods

buildQuery :: ByteString -> [Value] -> Query

pgsq :: QuasiQuoter

This quasi-quoter allows you to generate instances of Query. It lets you write SQL with some small enhancements. pgsq heavily relies on QueryTable which can be implemented by mkTable for a type of your choice.

Some syntax definitions that might be useful later on:

TypeName          ::= UpperAlpha {AlphaNumeric | '_'}
Name              ::= (Alpha | '_') {AlphaNumeric | '_'}
QualifiedTypeName ::= {TypeName '.'} TypeName

Alpha includes all alphabetical characters; UpperAlpha includes all upper-case alphabetical characters; AlphaNumeric includes all alpha-numeric characters.

Embed values

You can embed values whose types implement Column.

ValueExp ::= '$' Name

magicNumber :: Int
magicNumber = 1337

myQuery :: Query
myQuery =
    [pgsq| SELECT * FROM table t WHERE t.column1 > $magicNumber AND t.column2 < $otherNumber |]
    where otherNumber = magicNumber * 2

$magicNumber and $otherNumber are references to values magicNumber and otherNumber.

The quasi-quoter will generate a Query expression similar to the following.

Query "SELECT * FROM table t WHERE t.column1 > $1 AND t.column2 < $2"
      [pack magicNumber, pack otherNumber]

Table names

Types that implement QueryTable associate a table name with themselves. Since the table name is not always known to the user, one can insert it dynamically.

TableNameExp ::= '@' QualifiedTypeName

The @-operators is also an alias for the function ABS. If you have an expression that triggers the quasi-quoter such as @A, but you would like to use the ABS functionality, then simply reformat your expression to @(A) or ABS(A).

instance QueryTable YourType where
    tableName _ = "YourTable"

myQuery :: Query
myQuery =
    [pgsq| SELECT * FROM @YourType WHERE @YourType.column = 1337 |]

The table name will be inlined which results in the following.

Query "SELECT * FROM \"YourTable\" WHERE \"YourTable\".column = 1337" []

Identifier column names

Each instance of QueryTable also provides the name of the identifier column. Using this column name you can identify specific rows of a certain table.

TableIdentExp ::= '&' TypeName

& is also the operator for bitwise-AND. To resolve the ambiguity for expressions like A&B, simply reformat it to A & B or A&(B).

instance QueryTable YourType where
    tableName _   = "YourTable"
    tableIDName _ = "id"

listIDs :: Query
listIDs =
    [pgsq| SELECT &YourType FROM @YourType |]

listIDs is now a query which lists the IDs of each row. This is especially useful in combination with Reference.

fetchIDs :: Errand [Reference YourType]
fetchIDs =
    query [pgsq| SELECT &YourType FROM @YourType |]

Selectors

mkTable will automatically implement Result and QueryTable for you. This allows you to make use of the selector expander.

SelectorExp ::= '#' QualifiedTypeName

# is also the operator for bitwise-XOR. To resolve the ambiguity for expressions like A#B, simply reformat it to A # B or A#(B) or A#"B".

data Actor = Actor {
    actorName :: String,
    actorAge  :: Word
} deriving (Show, Eq, Ord)

mkTable ''Actor []

fetchOldActors :: Errand [Actor]
fetchOldActors =
    query [pgsq| SELECT #Actor FROM @Actor a WHERE a.actorAge >= $oldAge |]
    where oldAge = 70

#Actor will expand to a list of columns that are necessary to construct an instance of Actor. In this case it is equivalent to

@Actor.actorName, @Actor.actorAge

pgss :: QuasiQuoter

Just like pgsq but only produces the statement associated with the query. Referenced values are not inlined, they are simply dismissed.

class QueryTable a where

A type which implements this class can be used as a table in a quasi-quoted query. mkTable can implement this for you.

Minimal complete definition

tableName, tableIDName, tableSelectors

Methods

tableName :: Proxy a -> String

Unquoted name of the table

tableIDName :: Proxy a -> String

Unquoted name of the ID field

tableSelectors :: Proxy a -> [SelectorElement]

Selectors needed to retrieve all fields necessary to construct the type - think SELECT.

data SelectorElement

SELECT expression

Constructors

SelectorField String

Select a field. The field nme will be quoted and properly escaped.

SelectorSpecial String

Select a special expression. The expression will be inlined as is.

Instances

Eq SelectorElement

Methods

(==) :: SelectorElement -> SelectorElement -> Bool

(/=) :: SelectorElement -> SelectorElement -> Bool

Ord SelectorElement

Methods

compare :: SelectorElement -> SelectorElement -> Ordering

(<) :: SelectorElement -> SelectorElement -> Bool

(<=) :: SelectorElement -> SelectorElement -> Bool

(>) :: SelectorElement -> SelectorElement -> Bool

(>=) :: SelectorElement -> SelectorElement -> Bool

max :: SelectorElement -> SelectorElement -> SelectorElement

min :: SelectorElement -> SelectorElement -> SelectorElement

Show SelectorElement

Methods

showsPrec :: Int -> SelectorElement -> ShowS

show :: SelectorElement -> String

showList :: [SelectorElement] -> ShowS

Values

data Value

Query parameter or value of a column - see pack on how to generate Values manually but conveniently.

Constructors

Value

Fields

• valueType :: Oid

  Type object identifier

• valueData :: ByteString

  Data value

NullValue

Instances

Eq Value

Methods

(==) :: Value -> Value -> Bool

(/=) :: Value -> Value -> Bool

Ord Value

Methods

compare :: Value -> Value -> Ordering

(<) :: Value -> Value -> Bool

(<=) :: Value -> Value -> Bool

(>) :: Value -> Value -> Bool

(>=) :: Value -> Value -> Bool

max :: Value -> Value -> Value

min :: Value -> Value -> Value

Show Value

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

Column Value

Methods

pack :: Value -> Value

unpack :: Value -> Maybe Value

columnTypeName :: Proxy * Value -> String

columnAllowNull :: Proxy * Value -> Bool

columnCheck :: Proxy * Value -> String -> Maybe String

columnDescription :: Proxy * Value -> String -> String

QueryBuildable ByteString Value Query

Methods

buildQuery :: ByteString -> [Value] -> Query

class Column a where

Types which implement this type class may be used as column types.

Minimal complete definition

pack, unpack, columnTypeName

Methods

pack :: a -> Value

Pack column value.

unpack :: Value -> Maybe a

Unpack column value.

columnTypeName :: Proxy a -> String

Name of the underlying SQL type.

columnAllowNull :: Proxy a -> Bool

May the column be NULL?

columnCheck :: Proxy a -> String -> Maybe String

A condition that must hold true for the column.

columnDescription :: Proxy a -> String -> String

Generate column description in SQL. Think CREATE TABLE.

Instances

Column Bool

Methods

pack :: Bool -> Value

unpack :: Value -> Maybe Bool

columnTypeName :: Proxy * Bool -> String

columnAllowNull :: Proxy * Bool -> Bool

columnCheck :: Proxy * Bool -> String -> Maybe String

columnDescription :: Proxy * Bool -> String -> String

Column Int

Methods

pack :: Int -> Value

unpack :: Value -> Maybe Int

columnTypeName :: Proxy * Int -> String

columnAllowNull :: Proxy * Int -> Bool

columnCheck :: Proxy * Int -> String -> Maybe String

columnDescription :: Proxy * Int -> String -> String

Column Int8

Methods

pack :: Int8 -> Value

unpack :: Value -> Maybe Int8

columnTypeName :: Proxy * Int8 -> String

columnAllowNull :: Proxy * Int8 -> Bool

columnCheck :: Proxy * Int8 -> String -> Maybe String

columnDescription :: Proxy * Int8 -> String -> String

Column Int16

Methods

pack :: Int16 -> Value

unpack :: Value -> Maybe Int16

columnTypeName :: Proxy * Int16 -> String

columnAllowNull :: Proxy * Int16 -> Bool

columnCheck :: Proxy * Int16 -> String -> Maybe String

columnDescription :: Proxy * Int16 -> String -> String

Column Int32

Methods

pack :: Int32 -> Value

unpack :: Value -> Maybe Int32

columnTypeName :: Proxy * Int32 -> String

columnAllowNull :: Proxy * Int32 -> Bool

columnCheck :: Proxy * Int32 -> String -> Maybe String

columnDescription :: Proxy * Int32 -> String -> String

Column Int64

Methods

pack :: Int64 -> Value

unpack :: Value -> Maybe Int64

columnTypeName :: Proxy * Int64 -> String

columnAllowNull :: Proxy * Int64 -> Bool

columnCheck :: Proxy * Int64 -> String -> Maybe String

columnDescription :: Proxy * Int64 -> String -> String

Column Integer

Methods

pack :: Integer -> Value

unpack :: Value -> Maybe Integer

columnTypeName :: Proxy * Integer -> String

columnAllowNull :: Proxy * Integer -> Bool

columnCheck :: Proxy * Integer -> String -> Maybe String

columnDescription :: Proxy * Integer -> String -> String

Column Word

Methods

pack :: Word -> Value

unpack :: Value -> Maybe Word

columnTypeName :: Proxy * Word -> String

columnAllowNull :: Proxy * Word -> Bool

columnCheck :: Proxy * Word -> String -> Maybe String

columnDescription :: Proxy * Word -> String -> String

Column Word8

Methods

pack :: Word8 -> Value

unpack :: Value -> Maybe Word8

columnTypeName :: Proxy * Word8 -> String

columnAllowNull :: Proxy * Word8 -> Bool

columnCheck :: Proxy * Word8 -> String -> Maybe String

columnDescription :: Proxy * Word8 -> String -> String

Column Word16

Methods

pack :: Word16 -> Value

unpack :: Value -> Maybe Word16

columnTypeName :: Proxy * Word16 -> String

columnAllowNull :: Proxy * Word16 -> Bool

columnCheck :: Proxy * Word16 -> String -> Maybe String

columnDescription :: Proxy * Word16 -> String -> String

Column Word32

Methods

pack :: Word32 -> Value

unpack :: Value -> Maybe Word32

columnTypeName :: Proxy * Word32 -> String

columnAllowNull :: Proxy * Word32 -> Bool

columnCheck :: Proxy * Word32 -> String -> Maybe String

columnDescription :: Proxy * Word32 -> String -> String

Column Word64

Methods

pack :: Word64 -> Value

unpack :: Value -> Maybe Word64

columnTypeName :: Proxy * Word64 -> String

columnAllowNull :: Proxy * Word64 -> Bool

columnCheck :: Proxy * Word64 -> String -> Maybe String

columnDescription :: Proxy * Word64 -> String -> String

Column ByteString

Methods

pack :: ByteString -> Value

unpack :: Value -> Maybe ByteString

columnTypeName :: Proxy * ByteString -> String

columnAllowNull :: Proxy * ByteString -> Bool

columnCheck :: Proxy * ByteString -> String -> Maybe String

columnDescription :: Proxy * ByteString -> String -> String

Column ByteString

Methods

pack :: ByteString -> Value

unpack :: Value -> Maybe ByteString

columnTypeName :: Proxy * ByteString -> String

columnAllowNull :: Proxy * ByteString -> Bool

columnCheck :: Proxy * ByteString -> String -> Maybe String

columnDescription :: Proxy * ByteString -> String -> String

Column Text

Methods

pack :: Text -> Value

unpack :: Value -> Maybe Text

columnTypeName :: Proxy * Text -> String

columnAllowNull :: Proxy * Text -> Bool

columnCheck :: Proxy * Text -> String -> Maybe String

columnDescription :: Proxy * Text -> String -> String

Column Text

Methods

pack :: Text -> Value

unpack :: Value -> Maybe Text

columnTypeName :: Proxy * Text -> String

columnAllowNull :: Proxy * Text -> Bool

columnCheck :: Proxy * Text -> String -> Maybe String

columnDescription :: Proxy * Text -> String -> String

Column UTCTime

Methods

pack :: UTCTime -> Value

unpack :: Value -> Maybe UTCTime

columnTypeName :: Proxy * UTCTime -> String

columnAllowNull :: Proxy * UTCTime -> Bool

columnCheck :: Proxy * UTCTime -> String -> Maybe String

columnDescription :: Proxy * UTCTime -> String -> String

Column Value

Methods

pack :: Value -> Value

unpack :: Value -> Maybe Value

columnTypeName :: Proxy * Value -> String

columnAllowNull :: Proxy * Value -> Bool

columnCheck :: Proxy * Value -> String -> Maybe String

columnDescription :: Proxy * Value -> String -> String

Column [Char]

Methods

pack :: [Char] -> Value

unpack :: Value -> Maybe [Char]

columnTypeName :: Proxy * [Char] -> String

columnAllowNull :: Proxy * [Char] -> Bool

columnCheck :: Proxy * [Char] -> String -> Maybe String

columnDescription :: Proxy * [Char] -> String -> String

Column a => Column (Maybe a)

Methods

pack :: Maybe a -> Value

unpack :: Value -> Maybe (Maybe a)

columnTypeName :: Proxy * (Maybe a) -> String

columnAllowNull :: Proxy * (Maybe a) -> Bool

columnCheck :: Proxy * (Maybe a) -> String -> Maybe String

columnDescription :: Proxy * (Maybe a) -> String -> String

QueryTable a => Column (Reference a)

Methods

pack :: Reference a -> Value

unpack :: Value -> Maybe (Reference a)

columnTypeName :: Proxy * (Reference a) -> String

columnAllowNull :: Proxy * (Reference a) -> Bool

columnCheck :: Proxy * (Reference a) -> String -> Maybe String

columnDescription :: Proxy * (Reference a) -> String -> String

Results

class Result a where

Allows you to implement a custom result parser for your type. mkTable can implement this for your type.

Minimal complete definition

queryResultProcessor

Methods

queryResultProcessor :: ResultProcessor a

Instances

Column a => Result (Single a)

Methods

queryResultProcessor :: ResultProcessor (Single a)

Result (Reference a)

Methods

queryResultProcessor :: ResultProcessor (Reference a)

(Result a, Result b) => Result (a, b)

Combine result parsers sequencially.

Methods

queryResultProcessor :: ResultProcessor (a, b)

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

Methods

queryResultProcessor :: ResultProcessor (a, b, c)

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

Methods

queryResultProcessor :: ResultProcessor (a, b, c, d)

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

Methods

queryResultProcessor :: ResultProcessor (a, b, c, d, e)

(Result a, Result b, Result c, Result d, Result e, Result f) => Result (a, b, c, d, e, f)

Methods

queryResultProcessor :: ResultProcessor (a, b, c, d, e, f)

(Result a, Result b, Result c, Result d, Result e, Result f, Result g) => Result (a, b, c, d, e, f, g)

Methods

queryResultProcessor :: ResultProcessor (a, b, c, d, e, f, g)

data ResultProcessor a

Result processor

Instances

Monad ResultProcessor

Methods

(>>=) :: ResultProcessor a -> (a -> ResultProcessor b) -> ResultProcessor b

(>>) :: ResultProcessor a -> ResultProcessor b -> ResultProcessor b

return :: a -> ResultProcessor a

fail :: String -> ResultProcessor a

Functor ResultProcessor

Methods

fmap :: (a -> b) -> ResultProcessor a -> ResultProcessor b

(<$) :: a -> ResultProcessor b -> ResultProcessor a

Applicative ResultProcessor

Methods

pure :: a -> ResultProcessor a

(<*>) :: ResultProcessor (a -> b) -> ResultProcessor a -> ResultProcessor b

(*>) :: ResultProcessor a -> ResultProcessor b -> ResultProcessor b

(<*) :: ResultProcessor a -> ResultProcessor b -> ResultProcessor a

MonadIO ResultProcessor

Methods

liftIO :: IO a -> ResultProcessor a

MonadError ResultError ResultProcessor

Methods

throwError :: ResultError -> ResultProcessor a

catchError :: ResultProcessor a -> (ResultError -> ResultProcessor a) -> ResultProcessor a

data ResultError

Error that occured during result processing

Constructors

TooFewColumnsError Column

Occurs when you're trying to access a column that does not exist.

UnpackError Row Column Oid Format

The value at a given row and column could not be unpacked.

Instances

Eq ResultError

Methods

(==) :: ResultError -> ResultError -> Bool

(/=) :: ResultError -> ResultError -> Bool

Show ResultError

Methods

showsPrec :: Int -> ResultError -> ShowS

show :: ResultError -> String

showList :: [ResultError] -> ShowS

MonadError ResultError ResultProcessor

Methods

throwError :: ResultError -> ResultProcessor a

catchError :: ResultProcessor a -> (ResultError -> ResultProcessor a) -> ResultProcessor a

skipColumn :: ResultProcessor ()

Move cursor to the next column.

unpackColumn :: Column a => ResultProcessor a

Unpack the current column and move the cursor to the next column.

newtype Single a

Helper type to capture an single column.

Constructors

Single

Fields

• fromSingle :: a

Instances

Eq a => Eq (Single a)

Methods

(==) :: Single a -> Single a -> Bool

(/=) :: Single a -> Single a -> Bool

Ord a => Ord (Single a)

Methods

compare :: Single a -> Single a -> Ordering

(<) :: Single a -> Single a -> Bool

(<=) :: Single a -> Single a -> Bool

(>) :: Single a -> Single a -> Bool

(>=) :: Single a -> Single a -> Bool

max :: Single a -> Single a -> Single a

min :: Single a -> Single a -> Single a

Show a => Show (Single a)

Methods

showsPrec :: Int -> Single a -> ShowS

show :: Single a -> String

showList :: [Single a] -> ShowS

Column a => Result (Single a)

Methods

queryResultProcessor :: ResultProcessor (Single a)

newtype Reference a

Reference a row of type a.

Constructors

Reference

Fields

• referenceID :: Int64

Instances

Eq (Reference a)

Methods

(==) :: Reference a -> Reference a -> Bool

(/=) :: Reference a -> Reference a -> Bool

Ord (Reference a)

Methods

compare :: Reference a -> Reference a -> Ordering

(<) :: Reference a -> Reference a -> Bool

(<=) :: Reference a -> Reference a -> Bool

(>) :: Reference a -> Reference a -> Bool

(>=) :: Reference a -> Reference a -> Bool

max :: Reference a -> Reference a -> Reference a

min :: Reference a -> Reference a -> Reference a

Show (Reference a)

Methods

showsPrec :: Int -> Reference a -> ShowS

show :: Reference a -> String

showList :: [Reference a] -> ShowS

QueryTable a => Column (Reference a)

Methods

pack :: Reference a -> Value

unpack :: Value -> Maybe (Reference a)

columnTypeName :: Proxy * (Reference a) -> String

columnAllowNull :: Proxy * (Reference a) -> Bool

columnCheck :: Proxy * (Reference a) -> String -> Maybe String

columnDescription :: Proxy * (Reference a) -> String -> String

Result (Reference a)

Methods

queryResultProcessor :: ResultProcessor (Reference a)

Tables

class Table a where

Qualify a as a table type. mkTable can implement this class for you.

Minimal complete definition

insert, find, update, delete, createTableQuery

Methods

insert :: a -> Errand (Reference a)

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

insertMany :: [a] -> Errand [Reference a]

Insert multiple rows into the table at once.

find :: Reference a -> Errand a

Find the row identified by the given reference.

update :: Reference a -> a -> Errand ()

Update an existing row.

delete :: Reference a -> Errand ()

Delete a row from the table.

createTableQuery :: Proxy a -> Query

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

mkCreateQuery :: Name -> Q Exp

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

Example:

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

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

Implement the type classes QueryTable, Table and Result for the given 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, QuasiQuotes #-}
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 [Unique ['actorName], Check [pgss| actorAge >= 18 |]]

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

mkTable ''MovieCast [Unique ['movieCastMovie, 'movieCastActor]]

In this example, Reference takes care of adding the FOREIGN KEY constraint, so we don't have to.

data TableConstraint

Options to mkTable.

Constructors

Unique [Name]

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

Check String

The given statement must evaluate to true. Just like CHECK (statement) in SQL.

Instances

Eq TableConstraint

Methods

(==) :: TableConstraint -> TableConstraint -> Bool

(/=) :: TableConstraint -> TableConstraint -> Bool

Ord TableConstraint

Methods

compare :: TableConstraint -> TableConstraint -> Ordering

(<) :: TableConstraint -> TableConstraint -> Bool

(<=) :: TableConstraint -> TableConstraint -> Bool

(>) :: TableConstraint -> TableConstraint -> Bool

(>=) :: TableConstraint -> TableConstraint -> Bool

max :: TableConstraint -> TableConstraint -> TableConstraint

min :: TableConstraint -> TableConstraint -> TableConstraint

Show TableConstraint

Methods

showsPrec :: Int -> TableConstraint -> ShowS

show :: TableConstraint -> String

showList :: [TableConstraint] -> ShowS