Opaleye.Trans.Exception

This module wraps Trans and includes some basic exception handling. We handle SqlError and domain errors. By domain errors, we mean that the user of this library supplies an exception type for queries that could possibly fail.

Documentation

newtype OpaleyeT e m a

Constructors

OpaleyeT

Fields

• unOpaleyeT :: ExceptT e (OpaleyeT m) a

Instances

Monad m => MonadError e (OpaleyeT e m)

Methods

throwError :: e -> OpaleyeT e m a

catchError :: OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a

Monad m => MonadReader Connection (OpaleyeT e m)

Methods

ask :: OpaleyeT e m Connection

local :: (Connection -> Connection) -> OpaleyeT e m a -> OpaleyeT e m a

reader :: (Connection -> a) -> OpaleyeT e m a

MonadTrans (OpaleyeT e)

Methods

lift :: Monad m => m a -> OpaleyeT e m a

Monad m => Monad (OpaleyeT e m)

Methods

(>>=) :: OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b

(>>) :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b

return :: a -> OpaleyeT e m a

fail :: String -> OpaleyeT e m a

Functor m => Functor (OpaleyeT e m)

Methods

fmap :: (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b

(<$) :: a -> OpaleyeT e m b -> OpaleyeT e m a

Monad m => Applicative (OpaleyeT e m)

Methods

pure :: a -> OpaleyeT e m a

(<*>) :: OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b

(*>) :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b

(<*) :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a

MonadIO m => MonadIO (OpaleyeT e m)

Methods

liftIO :: IO a -> OpaleyeT e m a

data OpaleyeError e

OpaleyeErrors are either SqlErrors or DomainErrors

Constructors

SqlError SqlError

DomainError e

Instances

Eq e => Eq (OpaleyeError e)

Methods

(==) :: OpaleyeError e -> OpaleyeError e -> Bool

(/=) :: OpaleyeError e -> OpaleyeError e -> Bool

Show e => Show (OpaleyeError e)

Methods

showsPrec :: Int -> OpaleyeError e -> ShowS

show :: OpaleyeError e -> String

showList :: [OpaleyeError e] -> ShowS

runOpaleyeT :: Connection -> OpaleyeT e IO a -> IO (Either (OpaleyeError e) a)

Given a Connection, run an OpaleyeT

Transactions

data Transaction e a

Just like Transaction only with exception handling

Instances

MonadError e (Transaction e)

Methods

throwError :: e -> Transaction e a

catchError :: Transaction e a -> (e -> Transaction e a) -> Transaction e a

MonadReader Connection (Transaction e)

Methods

ask :: Transaction e Connection

local :: (Connection -> Connection) -> Transaction e a -> Transaction e a

reader :: (Connection -> a) -> Transaction e a

Monad (Transaction e)

Methods

(>>=) :: Transaction e a -> (a -> Transaction e b) -> Transaction e b

(>>) :: Transaction e a -> Transaction e b -> Transaction e b

return :: a -> Transaction e a

fail :: String -> Transaction e a

Functor (Transaction e)

Methods

fmap :: (a -> b) -> Transaction e a -> Transaction e b

(<$) :: a -> Transaction e b -> Transaction e a

Applicative (Transaction e)

Methods

pure :: a -> Transaction e a

(<*>) :: Transaction e (a -> b) -> Transaction e a -> Transaction e b

(*>) :: Transaction e a -> Transaction e b -> Transaction e b

(<*) :: Transaction e a -> Transaction e b -> Transaction e a

transaction :: MonadIO m => Transaction e a -> OpaleyeT e m a

Run a postgresql transaction in the OpaleyeT monad

run :: MonadIO m => Transaction e a -> OpaleyeT e m a

Execute a query without a literal transaction

Queries

query :: Default QueryRunner a b => Query a -> Transaction e [b]

Execute a Query. See runQuery.

queryFirst :: Default QueryRunner a b => e -> Query a -> Transaction e b

Retrieve the first result from a Query. Similar to listToMaybe $ runQuery.

Inserts

insert :: Table w r -> w -> Transaction e Int64

Insert into a Table. See runInsert.

insertMany :: Table w r -> [w] -> Transaction e Int64

Insert many records into a Table. See runInsertMany.

insertReturning :: Default QueryRunner a b => Table w r -> (r -> a) -> w -> Transaction e [b]

Insert a record into a Table with a return value. See runInsertReturning.

insertReturningFirst :: Default QueryRunner a b => e -> Table w r -> (r -> a) -> w -> Transaction e b

Insert a record into a Table with a return value. Retrieve only the first result. Similar to listToMaybe <$> insertReturning

insertManyReturning :: Default QueryRunner a b => Table w r -> [w] -> (r -> a) -> Transaction e [b]

Insert many records into a Table with a return value for each record.

Maybe not worth defining. This almost certainly does the wrong thing.

Updates

update :: Table w r -> (r -> w) -> (r -> Column PGBool) -> Transaction e Int64

Update items in a Table where the predicate is true. See runUpdate.

updateReturning :: Default QueryRunner a b => Table w r -> (r -> w) -> (r -> Column PGBool) -> (r -> a) -> Transaction e [b]

Update items in a Table with a return value. See runUpdateReturning.

updateReturningFirst :: Default QueryRunner a b => e -> Table w r -> (r -> w) -> (r -> Column PGBool) -> (r -> a) -> Transaction e b

Update items in a Table with a return value. Similar to listToMaybe <$> updateReturning.

Deletes

delete :: Table a b -> (b -> Column PGBool) -> Transaction e Int64

Delete items in a Table that satisfy some boolean predicate. See runDelete.

Exceptions

withExceptOpaleye :: Functor m => (e -> e') -> OpaleyeT e m a -> OpaleyeT e' m a

withExceptTrans :: (e -> e') -> Transaction e a -> Transaction e' a

opaleyeError :: (SqlError -> a) -> (e -> a) -> OpaleyeError e -> a

Dispatcher helper the two kinds of exceptions that OpaleyeT handles.

domainError :: MonadIO m => (e -> m a) -> OpaleyeError e -> m a

Dispatcher helper for domain errors. SqlErrors are rethrown.

Utilities

withError :: Monad m => OpaleyeT m (Either e b) -> OpaleyeT e m b

liftError :: Monad m => (Transaction (Either e a) -> OpaleyeT m (Either r b)) -> Transaction e a -> OpaleyeT r m b

withTrans :: Transaction a -> Transaction e a

maybeError :: Transaction (Maybe b) -> e -> Transaction e b

Reexports

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the IO monad.

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

Methods

liftIO :: IO a -> IO a

MonadIO m => MonadIO (OpaleyeT m)

Methods

liftIO :: IO a -> OpaleyeT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (ExceptT e m)

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (OpaleyeT e m)

Methods

liftIO :: IO a -> OpaleyeT e m a

MonadIO m => MonadIO (ReaderT * r m)

Methods

liftIO :: IO a -> ReaderT * r m a

ask :: MonadReader r m => m r

Retrieves the monad environment.

data Int64 :: *

64-bit signed integer type

Instances

Bounded Int64

Methods

minBound :: Int64

maxBound :: Int64

Enum Int64

Methods

succ :: Int64 -> Int64

pred :: Int64 -> Int64

toEnum :: Int -> Int64

fromEnum :: Int64 -> Int

enumFrom :: Int64 -> [Int64]

enumFromThen :: Int64 -> Int64 -> [Int64]

enumFromTo :: Int64 -> Int64 -> [Int64]

enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64]

Eq Int64

Methods

(==) :: Int64 -> Int64 -> Bool

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

Integral Int64

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

Num Int64

Methods

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

(*) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

abs :: Int64 -> Int64

signum :: Int64 -> Int64

fromInteger :: Integer -> Int64

Ord Int64

Methods

compare :: Int64 -> Int64 -> Ordering

(<) :: Int64 -> Int64 -> Bool

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

(>) :: Int64 -> Int64 -> Bool

(>=) :: Int64 -> Int64 -> Bool

max :: Int64 -> Int64 -> Int64

min :: Int64 -> Int64 -> Int64

Read Int64

Methods

readsPrec :: Int -> ReadS Int64

readList :: ReadS [Int64]

readPrec :: ReadPrec Int64

readListPrec :: ReadPrec [Int64]

Real Int64

Methods

toRational :: Int64 -> Rational

Show Int64

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Ix Int64

Methods

range :: (Int64, Int64) -> [Int64]

index :: (Int64, Int64) -> Int64 -> Int

unsafeIndex :: (Int64, Int64) -> Int64 -> Int

inRange :: (Int64, Int64) -> Int64 -> Bool

rangeSize :: (Int64, Int64) -> Int

unsafeRangeSize :: (Int64, Int64) -> Int

Bits Int64

Methods

(.&.) :: Int64 -> Int64 -> Int64

(.|.) :: Int64 -> Int64 -> Int64

xor :: Int64 -> Int64 -> Int64

complement :: Int64 -> Int64

shift :: Int64 -> Int -> Int64

rotate :: Int64 -> Int -> Int64

zeroBits :: Int64

bit :: Int -> Int64

setBit :: Int64 -> Int -> Int64

clearBit :: Int64 -> Int -> Int64

complementBit :: Int64 -> Int -> Int64

testBit :: Int64 -> Int -> Bool

bitSizeMaybe :: Int64 -> Maybe Int

bitSize :: Int64 -> Int

isSigned :: Int64 -> Bool

shiftL :: Int64 -> Int -> Int64

unsafeShiftL :: Int64 -> Int -> Int64

shiftR :: Int64 -> Int -> Int64

unsafeShiftR :: Int64 -> Int -> Int64

rotateL :: Int64 -> Int -> Int64

rotateR :: Int64 -> Int -> Int64

popCount :: Int64 -> Int

FiniteBits Int64

Methods

finiteBitSize :: Int64 -> Int

countLeadingZeros :: Int64 -> Int

countTrailingZeros :: Int64 -> Int

Unbox Int64

QueryRunnerColumnDefault PGInt8 Int64

Methods

queryRunnerColumnDefault :: QueryRunnerColumn PGInt8 Int64

Vector Vector Int64

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64)

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m ()

elemseq :: Vector Int64 -> Int64 -> b -> b

MVector MVector Int64

Methods

basicLength :: MVector s Int64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64)

data Vector Int64

data Vector Int64 = V_Int64 (Vector Int64)

data MVector s Int64

data MVector s Int64 = MV_Int64 (MVector s Int64)

throwError :: MonadError e m => forall a. e -> m a

Is used within a monadic computation to begin exception processing.

catchError :: MonadError e m => forall a. m a -> (e -> m a) -> m a

A handler function to handle previous errors and return to normal execution. A common idiom is:

do { action1; action2; action3 } `catchError` handler

where the action functions can call throwError. Note that handler and the do-block must have the same return type.