Database.Seakale.PostgreSQL

Documentation

data Connection :: *

Connection encapsulates a connection to the backend.

Instances

Eq Connection

Methods

(==) :: Connection -> Connection -> Bool

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

Monad m => HasConnection (ReaderT * Connection m)

Methods

withConn :: (Connection -> ReaderT * Connection m a) -> ReaderT * Connection m a

data ConnectInfo

Constructors

ConnectInfo

Fields

• ciHostname :: String
• ciPort :: Word16
• ciUsername :: String
• ciPassword :: String
• ciDatabase :: String

connect :: ConnectInfo -> IO Connection

connectString :: ByteString -> IO Connection

disconnect :: Connection -> IO ()

type Request = Request PSQL

type RequestT = RequestT PSQL

runRequest :: (HasConnection m, MonadIO m) => PSQL -> Request a -> m (Either SeakaleError a)

runRequestT :: (HasConnection m, MonadIO m) => PSQL -> RequestT m a -> m (Either SeakaleError a)

type Select = Select PSQL

type SelectT = SelectT PSQL

runSelect :: Select a -> Request a

runSelectT :: Monad m => SelectT m a -> RequestT m a

type Store = Store PSQL

type StoreT m = StoreT PSQL m

runStore :: Store a -> Request a

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

class Monad m => HasConnection m where

Minimal complete definition

withConn

Methods

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

Instances

HasConnection m => HasConnection (ExceptT e m)

Methods

withConn :: (Connection -> ExceptT e m a) -> ExceptT e m a

HasConnection m => HasConnection (StateT s m)

Methods

withConn :: (Connection -> StateT s m a) -> StateT s m a

Monad m => HasConnection (ReaderT * Connection m)

Methods

withConn :: (Connection -> ReaderT * Connection m a) -> ReaderT * Connection m a

data PSQL

Constructors

PSQL

Fields

• psqlLogQueries :: Bool

Instances

Backend PSQL

Associated Types

type ColumnType PSQL :: *

type MonadBackend PSQL (m :: * -> *) :: Constraint

Methods

runQuery :: MonadBackend PSQL m => PSQL -> ByteString -> m (Either ByteString ([ColumnInfo PSQL], [Row PSQL]))

runExecute :: MonadBackend PSQL m => PSQL -> ByteString -> m (Either ByteString Integer)

type ColumnType PSQL

type ColumnType PSQL = ByteString

type MonadBackend PSQL m

type MonadBackend PSQL m

defaultPSQL :: PSQL

data SeakaleError :: *

Constructors

RowParseError String

BackendError ByteString

EntityNotFoundError

Instances

Eq SeakaleError

Methods

(==) :: SeakaleError -> SeakaleError -> Bool

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

Show SeakaleError

Methods

showsPrec :: Int -> SeakaleError -> ShowS

show :: SeakaleError -> String

showList :: [SeakaleError] -> ShowS

data Query a :: Nat -> * where

Constructors

Plain :: Query a

Hole :: Query (S n)

EmptyQuery :: Query O

newtype Field backend :: * -> *

Constructors

Field

Fields

• fieldValue :: Maybe ByteString

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

Fields

• colInfoName :: Maybe ByteString
• colInfoType :: ColumnType backend

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

type QueryData n = Vector n ByteString

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

nil :: Vector Zero a

(<:|) :: 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