Database.DSH

This module is intended to be imported qualified, to avoid name clashes with Prelude functions. For example:

 import qualified Database.DSH as Q
 import Database.DSH (Q)

Alternatively you can hide Prelude and import this module like this:

 import Prelude ()
 import Database.DSH

In this case you still get Prelude definitions that are not provided by Database.DSH.

Unit

unit :: Q ()

Boolean logic

false :: Q Bool

true :: Q Bool

not :: Q Bool -> Q Bool

(&&) :: Q Bool -> Q Bool -> Q Bool

(||) :: Q Bool -> Q Bool -> Q Bool

Equality and Ordering

eq :: (Eq a, QA a) => Q a -> Q a -> Q Bool

(==) :: (Eq a, QA a) => Q a -> Q a -> Q Bool

neq :: (Eq a, QA a) => Q a -> Q a -> Q Bool

(/=) :: (Eq a, QA a) => Q a -> Q a -> Q Bool

lt :: (Ord a, QA a) => Q a -> Q a -> Q Bool

(<) :: (Ord a, QA a) => Q a -> Q a -> Q Bool

lte :: (Ord a, QA a) => Q a -> Q a -> Q Bool

(<=) :: (Ord a, QA a) => Q a -> Q a -> Q Bool

gte :: (Ord a, QA a) => Q a -> Q a -> Q Bool

(>=) :: (Ord a, QA a) => Q a -> Q a -> Q Bool

gt :: (Ord a, QA a) => Q a -> Q a -> Q Bool

(>) :: (Ord a, QA a) => Q a -> Q a -> Q Bool

min :: forall a. (Ord a, QA a) => Q a -> Q a -> Q a

max :: forall a. (Ord a, QA a) => Q a -> Q a -> Q a

Conditionals

bool :: QA a => Q a -> Q a -> Q Bool -> Q a

Boolean fold | It's first argument is used in the case of False | It's second argument is used in the case of True | The third argument is the boolean

cond :: forall a. QA a => Q Bool -> Q a -> Q a -> Q a

(?) :: QA a => Q Bool -> (Q a, Q a) -> Q a

List Construction

nil :: forall a. QA a => Q [a]

empty :: QA a => Q [a]

cons :: forall a. QA a => Q a -> Q [a] -> Q [a]

(<|) :: QA a => Q a -> Q [a] -> Q [a]

snoc :: forall a. QA a => Q [a] -> Q a -> Q [a]

(|>) :: QA a => Q [a] -> Q a -> Q [a]

singleton :: QA a => Q a -> Q [a]

List Operations

head :: forall a. QA a => Q [a] -> Q a

tail :: forall a. QA a => Q [a] -> Q [a]

take :: forall a. QA a => Q Integer -> Q [a] -> Q [a]

drop :: forall a. QA a => Q Integer -> Q [a] -> Q [a]

map :: forall a b. (QA a, QA b) => (Q a -> Q b) -> Q [a] -> Q [b]

append :: forall a. QA a => Q [a] -> Q [a] -> Q [a]

(><) :: QA a => Q [a] -> Q [a] -> Q [a]

filter :: forall a. QA a => (Q a -> Q Bool) -> Q [a] -> Q [a]

groupWith :: forall a b. (Ord b, QA a, QA b) => (Q a -> Q b) -> Q [a] -> Q [[a]]

sortWith :: forall a b. (Ord b, QA a, QA b) => (Q a -> Q b) -> Q [a] -> Q [a]

the :: forall a. (Eq a, QA a) => Q [a] -> Q a

last :: forall a. QA a => Q [a] -> Q a

init :: forall a. QA a => Q [a] -> Q [a]

null :: QA a => Q [a] -> Q Bool

length :: QA a => Q [a] -> Q Integer

index :: forall a. QA a => Q [a] -> Q Integer -> Q a

(!!) :: QA a => Q [a] -> Q Integer -> Q a

reverse :: forall a. QA a => Q [a] -> Q [a]

Special folds

and :: Q [Bool] -> Q Bool

or :: Q [Bool] -> Q Bool

any :: QA a => (Q a -> Q Bool) -> Q [a] -> Q Bool

all :: QA a => (Q a -> Q Bool) -> Q [a] -> Q Bool

sum :: forall a. (QA a, Num a) => Q [a] -> Q a

concat :: forall a. QA a => Q [[a]] -> Q [a]

concatMap :: (QA a, QA b) => (Q a -> Q [b]) -> Q [a] -> Q [b]

maximum :: forall a. (QA a, Ord a) => Q [a] -> Q a

minimum :: forall a. (QA a, Ord a) => Q [a] -> Q a

Sublists

splitAt :: forall a. QA a => Q Integer -> Q [a] -> Q ([a], [a])

takeWhile :: forall a. QA a => (Q a -> Q Bool) -> Q [a] -> Q [a]

dropWhile :: forall a. QA a => (Q a -> Q Bool) -> Q [a] -> Q [a]

span :: forall a. QA a => (Q a -> Q Bool) -> Q [a] -> Q ([a], [a])

break :: forall a. QA a => (Q a -> Q Bool) -> Q [a] -> Q ([a], [a])

Searching Lists

elem :: forall a. (Eq a, QA a) => Q a -> Q [a] -> Q Bool

notElem :: forall a. (Eq a, QA a) => Q a -> Q [a] -> Q Bool

Zipping and Unzipping Lists

zip :: forall a b. (QA a, QA b) => Q [a] -> Q [b] -> Q [(a, b)]

zipWith :: forall a b c. (QA a, QA b, QA c) => (Q a -> Q b -> Q c) -> Q [a] -> Q [b] -> Q [c]

unzip :: forall a b. (QA a, QA b) => Q [(a, b)] -> Q ([a], [b])

Set operations

nub :: forall a. (Eq a, QA a) => Q [a] -> Q [a]

Tuple Projection Functions

fst :: forall a b. (QA a, QA b) => Q (a, b) -> Q a

snd :: forall a b. (QA a, QA b) => Q (a, b) -> Q b

Conversions between numeric types

integerToDouble :: Q Integer -> Q Double

Convert Haskell values into DB queries

toQ :: forall a. QA a => a -> Q a

Missing Combinators

This module offers most of the functions on lists given in PreludeList for the Q type. Missing functions are:

General folds:

 foldl
 foldl1
 scanl
 scanl1
 foldr
 foldr1
 scanr
 scanr1

Infinit lists:

 iterate
 repeat
 cycle

String functions:

 lines
 words
 unlines
 unwords

Searching lists:

 lookup

Zipping and unzipping lists:

 zip3
 zipWith3
 unzip3

Data Types

data Q a

Instances

Typeable1 Q

Eq (Q Double)

Eq (Q Integer)

Fractional (Q Double)

Data a => Data (Q a)

Num (Q Double)

Num (Q Integer)

Show (Q a)

IsString (Q Text)

View (Q Bool) (Q Bool)

View (Q Char) (Q Char)

View (Q Double) (Q Double)

View (Q Integer) (Q Integer)

View (Q ()) (Q ())

View (Q Text) (Q Text)

(QA a, QA b) => View (Q (a, b)) (Q a, Q b)

(QA a1, QA a2, QA a3) => View (Q (a1, a2, a3)) (Q a1, Q a2, Q a3)

(QA a1, QA a2, QA a3, QA a4) => View (Q (a1, a2, a3, a4)) (Q a1, Q a2, Q a3, Q a4)

(QA a1, QA a2, QA a3, QA a4, QA a5) => View (Q (a1, a2, a3, a4, a5)) (Q a1, Q a2, Q a3, Q a4, Q a5)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6) => View (Q (a1, a2, a3, a4, a5, a6)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7) => View (Q (a1, a2, a3, a4, a5, a6, a7)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6, Q a7)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7, QA a8) => View (Q (a1, a2, a3, a4, a5, a6, a7, a8)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6, Q a7, Q a8)

Type Classes

class QA a

Instances

QA Bool

QA Char

QA Double

QA Integer

QA ()

QA Text

QA a => QA [a]

(QA a, QA b) => QA (a, b)

(QA a1, QA a2, QA a3) => QA (a1, a2, a3)

(QA a1, QA a2, QA a3, QA a4) => QA (a1, a2, a3, a4)

(QA a1, QA a2, QA a3, QA a4, QA a5) => QA (a1, a2, a3, a4, a5)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6) => QA (a1, a2, a3, a4, a5, a6)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7) => QA (a1, a2, a3, a4, a5, a6, a7)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7, QA a8) => QA (a1, a2, a3, a4, a5, a6, a7, a8)

class QA a => TA a

Instances

TA Bool

TA Char

TA Double

TA Integer

TA ()

TA Text

(BasicType a, BasicType b, QA a, QA b) => TA (a, b)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3) => TA (a1, a2, a3)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3, QA a4, BasicType a4) => TA (a1, a2, a3, a4)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3, QA a4, BasicType a4, QA a5, BasicType a5) => TA (a1, a2, a3, a4, a5)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3, QA a4, BasicType a4, QA a5, BasicType a5, QA a6, BasicType a6) => TA (a1, a2, a3, a4, a5, a6)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3, QA a4, BasicType a4, QA a5, BasicType a5, QA a6, BasicType a6, QA a7, BasicType a7) => TA (a1, a2, a3, a4, a5, a6, a7)

(QA a1, BasicType a1, QA a2, BasicType a2, QA a3, BasicType a3, QA a4, BasicType a4, QA a5, BasicType a5, QA a6, BasicType a6, QA a7, BasicType a7, QA a8, BasicType a8) => TA (a1, a2, a3, a4, a5, a6, a7, a8)

table :: TA a => String -> Q [a]

tableDB :: TA a => String -> Q [a]

tableCSV :: TA a => String -> Q [a]

tableWithKeys :: TA a => String -> [[String]] -> Q [a]

class BasicType a

Instances

BasicType Bool

BasicType Char

BasicType Double

BasicType Integer

BasicType ()

BasicType Text

class View a b | a -> b, b -> a where

Methods

view :: a -> b

fromView :: b -> a

Instances

View (Q Bool) (Q Bool)

View (Q Char) (Q Char)

View (Q Double) (Q Double)

View (Q Integer) (Q Integer)

View (Q ()) (Q ())

View (Q Text) (Q Text)

(QA a, QA b) => View (Q (a, b)) (Q a, Q b)

(QA a1, QA a2, QA a3) => View (Q (a1, a2, a3)) (Q a1, Q a2, Q a3)

(QA a1, QA a2, QA a3, QA a4) => View (Q (a1, a2, a3, a4)) (Q a1, Q a2, Q a3, Q a4)

(QA a1, QA a2, QA a3, QA a4, QA a5) => View (Q (a1, a2, a3, a4, a5)) (Q a1, Q a2, Q a3, Q a4, Q a5)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6) => View (Q (a1, a2, a3, a4, a5, a6)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7) => View (Q (a1, a2, a3, a4, a5, a6, a7)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6, Q a7)

(QA a1, QA a2, QA a3, QA a4, QA a5, QA a6, QA a7, QA a8) => View (Q (a1, a2, a3, a4, a5, a6, a7, a8)) (Q a1, Q a2, Q a3, Q a4, Q a5, Q a6, Q a7, Q a8)

tuple :: View a b => b -> a

record :: View a b => b -> a

Quasiquoter

qc :: QuasiQuoter

Template Haskell: Creating Table Representations

generateRecords

Arguments

:: IConnection conn

=> IO conn

Database connection

-> String

Table name

-> String

Data type name for each row of the table

-> [Name]

Default deriving instances

-> Q [Dec]

Lookup a database table, create corresponding Haskell record data types and generate QA and View instances

Example usage:

 $(generateRecords myConnection "users" "User" [''Show,''Eq])

Note that the da is created at compile time, not at run time!

generateInstances :: Q [Dec] -> Q [Dec]

Derive QA and View instances for record definitions

Example usage:

 $(generateInstances [d|

     data User = User
         { userId    :: Int
         , userName  :: String
         }

   |])

This generates the following record type, which can be used in view patterns

 data UserV = UserV
     { userIdV    :: Q Int
     , userNameV  :: Q String
     }

 instance View (Q User) UserV

and the liftet record selectors:

 userIdQ      :: Q User -> Q Int
 userNameQ    :: Q User -> Q String

csvImport :: FilePath -> Type -> IO Norm

csvExport :: TA a => FilePath -> [a] -> IO ()

module Data.Text

module Database.HDBC

module Prelude