Database.Seakale.Types

Documentation

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

class Monad m => MonadSeakaleBase backend m | m -> backend where

Minimal complete definition

getBackend, throwSeakaleError, catchSeakaleError

Methods

getBackend :: m backend

throwSeakaleError :: SeakaleError -> m a

catchSeakaleError :: m a -> (SeakaleError -> m a) -> m a

Instances

(Monoid w, MonadSeakaleBase backend m) => MonadSeakaleBase backend (WriterT w m)

Methods

getBackend :: WriterT w m backend

throwSeakaleError :: SeakaleError -> WriterT w m a

catchSeakaleError :: WriterT w m a -> (SeakaleError -> WriterT w m a) -> WriterT w m a

MonadSeakaleBase backend m => MonadSeakaleBase backend (StateT s m)

Methods

getBackend :: StateT s m backend

throwSeakaleError :: SeakaleError -> StateT s m a

catchSeakaleError :: StateT s m a -> (SeakaleError -> StateT s m a) -> StateT s m a

MonadSeakaleBase backend m => MonadSeakaleBase backend (ExceptT e m)

Methods

getBackend :: ExceptT e m backend

throwSeakaleError :: SeakaleError -> ExceptT e m a

catchSeakaleError :: ExceptT e m a -> (SeakaleError -> ExceptT e m a) -> ExceptT e m a

Monad m => MonadSeakaleBase backend (FreeT (RequestF backend) m)

Methods

getBackend :: FreeT (RequestF backend) m backend

throwSeakaleError :: SeakaleError -> FreeT (RequestF backend) m a

catchSeakaleError :: FreeT (RequestF backend) m a -> (SeakaleError -> FreeT (RequestF backend) m a) -> FreeT (RequestF backend) m a

MonadSeakaleBase backend m => MonadSeakaleBase backend (FreeT (StoreF backend) m)

Methods

getBackend :: FreeT (StoreF backend) m backend

throwSeakaleError :: SeakaleError -> FreeT (StoreF backend) m a

catchSeakaleError :: FreeT (StoreF backend) m a -> (SeakaleError -> FreeT (StoreF backend) m a) -> FreeT (StoreF backend) m a

Monad m => MonadSeakaleBase backend (FreeT (SelectF backend) m)

Methods

getBackend :: FreeT (SelectF backend) m backend

throwSeakaleError :: SeakaleError -> FreeT (SelectF backend) m a

catchSeakaleError :: FreeT (SelectF backend) m a -> (SeakaleError -> FreeT (SelectF backend) m a) -> FreeT (SelectF backend) m a

MonadSeakaleBase backend m => MonadSeakaleBase backend (ReaderT * r m)

Methods

getBackend :: ReaderT * r m backend

throwSeakaleError :: SeakaleError -> ReaderT * r m a

catchSeakaleError :: ReaderT * r m a -> (SeakaleError -> ReaderT * r m a) -> ReaderT * r m a

data Nat

Constructors

O

S Nat

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

type family (n :: Nat) :+ (m :: Nat) :: Nat

Instances

type O :+ n

type O :+ n = n

type (S n) :+ m

type (S n) :+ m = S ((:+) n m)

data Query :: Nat -> * where

Constructors

Plain :: ByteString -> Query n -> Query n

Hole :: Query n -> Query (S n)

EmptyQuery :: Query Zero

eqQuery :: Query n -> Query m -> Bool

qappend :: Query n -> Query m -> Query (n :+ m)

qappendZero :: Query n -> Query Zero -> Query n

parenthesiseQuery :: Query n -> Query n

data RepeatQuery :: Nat -> Nat -> Nat -> * where

Constructors

RepeatQuery :: Query k -> Query l -> ByteString -> Query i -> RepeatQuery k l i

formatQuery :: Query n -> QueryData n -> ByteString

formatMany :: RepeatQuery k l i -> QueryData k -> QueryData i -> [QueryData l] -> ByteString

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]

class Backend backend where

Minimal complete definition

runQuery, runExecute

Associated Types

type ColumnType backend :: *

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

Methods

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

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

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 (Maybe ByteString)

data Vector :: Nat -> * -> * where

Constructors

Cons :: a -> Vector n a -> Vector (S n) a

Nil :: Vector Zero a

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 Zero)

Methods

ntimes :: a -> Vector Zero a

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

Methods

ntimes :: a -> 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)]

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

Eq a => Eq (Vector n a)

Methods

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

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

type Item (Vector Zero a)

type Item (Vector Zero a) = a

type Item (Vector (S n) a)

type Item (Vector (S n) 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

vappend :: Vector n a -> Vector m a -> Vector (n :+ m) a

vzip :: Vector n a -> Vector n b -> Vector n (a, b)

vectorToList :: Vector n a -> [a]

singleton :: a -> Vector One a

eqVector :: Eq a => Vector n a -> Vector m a -> Bool

class NTimes f where

Minimal complete definition

ntimes

Methods

ntimes :: a -> f a

Instances

NTimes (Vector Zero)

Methods

ntimes :: a -> Vector Zero a

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

Methods

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

data Null

Constructors

Null

Instances

ToRow backend One Null

Methods

toRow :: backend -> Null -> QueryData One

FromRow backend One Null

Methods

fromRow :: RowParser backend One Null