seakale-postgresql-0.1.1.0: PostgreSQL backend for Seakale

Safe HaskellNone
LanguageHaskell2010

Database.Seakale.PostgreSQL

Synopsis

Documentation

data Connection :: * #

Connection encapsulates a connection to the backend.

runStoreT :: Monad m => StoreT m a -> RequestT m a Source #

class Monad m => HasConnection m where Source #

Minimal complete definition

withConn

Methods

withConn :: (Connection -> m a) -> m a Source #

data Query a :: Nat -> * where #

Constructors

Plain :: Query a 
Hole :: Query (S n) 
EmptyQuery :: Query O 

newtype Field backend :: * -> * #

Constructors

Field 

Instances

Eq (Field backend) 

Methods

(==) :: Field backend -> Field backend -> Bool #

(/=) :: Field backend -> Field backend -> Bool #

Show (Field backend) 

Methods

showsPrec :: Int -> Field backend -> ShowS #

show :: Field backend -> String #

showList :: [Field backend] -> ShowS #

type Row backend = [Field backend] #

data ColumnInfo backend :: * -> * #

Constructors

ColumnInfo 

Instances

Eq (ColumnType backend) => Eq (ColumnInfo backend) 

Methods

(==) :: ColumnInfo backend -> ColumnInfo backend -> Bool #

(/=) :: ColumnInfo backend -> ColumnInfo backend -> Bool #

Show (ColumnType backend) => Show (ColumnInfo backend) 

Methods

showsPrec :: Int -> ColumnInfo backend -> ShowS #

show :: ColumnInfo backend -> String #

showList :: [ColumnInfo backend] -> ShowS #

data Vector a b :: Nat -> * -> * where #

Constructors

Cons :: Vector (S n) b 
Nil :: Vector O b 

Instances

FromRow backend Zero (Vector Zero a) 

Methods

fromRow :: RowParser backend Zero (Vector Zero a) #

(FromRow backend One a, FromRow backend n (Vector n a)) => FromRow backend (S n) (Vector (S n) a) 

Methods

fromRow :: RowParser backend (S n) (Vector (S n) a) #

Functor (Vector n) 

Methods

fmap :: (a -> b) -> Vector n a -> Vector n b #

(<$) :: a -> Vector n b -> Vector n a #

NTimes (Vector n) => NTimes (Vector (S n)) 

Methods

ntimes :: a -> Vector (S n) a #

NTimes (Vector Zero) 

Methods

ntimes :: a -> Vector Zero a #

(IsList (Vector n a), (~) * (Item (Vector n a)) a) => IsList (Vector (S n) a) 

Associated Types

type Item (Vector (S n) a) :: * #

Methods

fromList :: [Item (Vector (S n) a)] -> Vector (S n) a #

fromListN :: Int -> [Item (Vector (S n) a)] -> Vector (S n) a #

toList :: Vector (S n) a -> [Item (Vector (S n) a)] #

IsList (Vector Zero a) 

Associated Types

type Item (Vector Zero a) :: * #

Methods

fromList :: [Item (Vector Zero a)] -> Vector Zero a #

fromListN :: Int -> [Item (Vector Zero a)] -> Vector Zero a #

toList :: Vector Zero a -> [Item (Vector Zero a)] #

Eq a => Eq (Vector n a) 

Methods

(==) :: Vector n a -> Vector n a -> Bool #

(/=) :: Vector n a -> Vector n a -> Bool #

type Item (Vector (S n) a) 
type Item (Vector (S n) a) = a
type Item (Vector Zero a) 
type Item (Vector Zero a) = a

cons :: a -> Vector n a -> Vector (S n) a #

(<:>) :: a -> Vector n a -> Vector (S n) a infixr 5 #

(<:|) :: a -> a -> Vector Two a infixr 5 #

type Zero = O #

type One = S Zero #

type Two = S One #

type Three = S Two #

type Four = S Three #

type Five = S Four #

type Six = S Five #

type Seven = S Six #

type Eight = S Seven #

type Nine = S Eight #

type Ten = S Nine #