module Database.PostgreSQL.PQTypes.Utils (
throwDB
, raw
, runQuery_
, runQuery01
, runQuery01_
, runSQL
, runSQL_
, runSQL01
, runSQL01_
, hpqTypesError
) where
import Control.Monad
import Control.Monad.Catch
import Database.PostgreSQL.PQTypes.Class
import Database.PostgreSQL.PQTypes.Internal.Error
import Database.PostgreSQL.PQTypes.Internal.Exception
import Database.PostgreSQL.PQTypes.Internal.Utils
import Database.PostgreSQL.PQTypes.SQL
import Database.PostgreSQL.PQTypes.SQL.Class
import Database.PostgreSQL.PQTypes.SQL.Raw
{-# INLINABLE throwDB #-}
throwDB :: (Exception e, MonadDB m, MonadThrow m) => e -> m a
throwDB :: e -> m a
throwDB e
e = case SomeException -> Maybe DBException
forall e. Exception e => SomeException -> Maybe e
fromException (SomeException -> Maybe DBException)
-> SomeException -> Maybe DBException
forall a b. (a -> b) -> a -> b
$ e -> SomeException
forall e. Exception e => e -> SomeException
toException e
e of
Just (DBException
dbe::DBException) -> DBException -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM DBException
dbe
Maybe DBException
Nothing -> do
SomeSQL sql
sql <- m SomeSQL
forall (m :: * -> *). MonadDB m => m SomeSQL
getLastQuery
DBException -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM DBException :: forall e sql. (Exception e, Show sql) => sql -> e -> DBException
DBException {
dbeQueryContext :: sql
dbeQueryContext = sql
sql
, dbeError :: e
dbeError = e
e
}
raw :: RawSQL () -> SQL
raw :: RawSQL () -> SQL
raw = Text -> SQL
mkSQL (Text -> SQL) -> (RawSQL () -> Text) -> RawSQL () -> SQL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RawSQL () -> Text
unRawSQL
{-# INLINABLE runQuery_ #-}
runQuery_ :: (IsSQL sql, MonadDB m) => sql -> m ()
runQuery_ :: sql -> m ()
runQuery_ = m Int -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Int -> m ()) -> (sql -> m Int) -> sql -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. sql -> m Int
forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery
{-# INLINABLE runQuery01 #-}
runQuery01 :: (IsSQL sql, MonadDB m, MonadThrow m) => sql -> m Bool
runQuery01 :: sql -> m Bool
runQuery01 sql
sql = do
Int
n <- sql -> m Int
forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery sql
sql
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ AffectedRowsMismatch -> m ()
forall e (m :: * -> *) a.
(Exception e, MonadDB m, MonadThrow m) =>
e -> m a
throwDB AffectedRowsMismatch :: [(Int, Int)] -> Int -> AffectedRowsMismatch
AffectedRowsMismatch {
rowsExpected :: [(Int, Int)]
rowsExpected = [(Int
0, Int
1)]
, rowsDelivered :: Int
rowsDelivered = Int
n
}
Bool -> m Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1
{-# INLINABLE runQuery01_ #-}
runQuery01_ :: (IsSQL sql, MonadDB m, MonadThrow m) => sql -> m ()
runQuery01_ :: sql -> m ()
runQuery01_ = m Bool -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Bool -> m ()) -> (sql -> m Bool) -> sql -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. sql -> m Bool
forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m Bool
runQuery01
{-# INLINABLE runSQL #-}
runSQL :: MonadDB m => SQL -> m Int
runSQL :: SQL -> m Int
runSQL = SQL -> m Int
forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery
{-# INLINABLE runSQL_ #-}
runSQL_ :: MonadDB m => SQL -> m ()
runSQL_ :: SQL -> m ()
runSQL_ = SQL -> m ()
forall sql (m :: * -> *). (IsSQL sql, MonadDB m) => sql -> m ()
runQuery_
{-# INLINABLE runSQL01 #-}
runSQL01 :: (MonadDB m, MonadThrow m) => SQL -> m Bool
runSQL01 :: SQL -> m Bool
runSQL01 = SQL -> m Bool
forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m Bool
runQuery01
{-# INLINABLE runSQL01_ #-}
runSQL01_ :: (MonadDB m, MonadThrow m) => SQL -> m ()
runSQL01_ :: SQL -> m ()
runSQL01_ = SQL -> m ()
forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m ()
runQuery01_