module Database.PostgreSQL.PQTypes.Utils (
    throwDB
  , raw
  , runQuery_
  , runQuery01
  , runQuery01_
  , runSQL
  , runSQL_
  , runSQL01
  , runSQL01_
  , runPreparedQuery_
  , runPreparedQuery01
  , runPreparedQuery01_
  , runPreparedSQL
  , runPreparedSQL_
  , runPreparedSQL01
  , runPreparedSQL01_
  -- Internal.Utils
  , 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

-- | When given 'DBException', throw it immediately. Otherwise
-- wrap it in 'DBException' with the current query context first.
throwDB :: (Exception e, MonadDB m, MonadThrow m) => e -> m a
throwDB :: forall e (m :: * -> *) a.
(Exception e, MonadDB m, MonadThrow m) =>
e -> m a
throwDB e
e = case forall e. Exception e => SomeException -> Maybe e
fromException forall a b. (a -> b) -> a -> b
$ forall e. Exception e => e -> SomeException
toException e
e of
  Just (DBException
dbe::DBException) -> forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM DBException
dbe
  Maybe DBException
Nothing -> do
    SomeSQL sql
sql <- forall (m :: * -> *). MonadDB m => m SomeSQL
getLastQuery
    forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM DBException {
      dbeQueryContext :: sql
dbeQueryContext = sql
sql
    , dbeError :: e
dbeError = e
e
    }

----------------------------------------

-- | Convert 'RawSQL' () to 'SQL'.
raw :: RawSQL () -> SQL
raw :: RawSQL () -> SQL
raw = Text -> SQL
mkSQL forall b c a. (b -> c) -> (a -> b) -> a -> c
. RawSQL () -> Text
unRawSQL

----------------------------------------

-- | Specialization of 'runQuery' that discards the result.
runQuery_ :: (IsSQL sql, MonadDB m) => sql -> m ()
runQuery_ :: forall sql (m :: * -> *). (IsSQL sql, MonadDB m) => sql -> m ()
runQuery_ = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery

-- | Specialization of 'runQuery' that checks whether affected/returned
-- number of rows is in range [0, 1] and returns appropriate 'Bool' value.
-- Otherwise, 'AffectedRowsMismatch' exception is thrown.
runQuery01 :: (IsSQL sql, MonadDB m, MonadThrow m) => sql -> m Bool
runQuery01 :: forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m Bool
runQuery01 sql
sql = do
  Int
n <- forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery sql
sql
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a.
(Exception e, MonadDB m, MonadThrow m) =>
e -> m a
throwDB AffectedRowsMismatch {
    rowsExpected :: [(Int, Int)]
rowsExpected = [(Int
0, Int
1)]
  , rowsDelivered :: Int
rowsDelivered = Int
n
  }
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int
n forall a. Eq a => a -> a -> Bool
== Int
1

-- | Specialization of 'runQuery01' that discards the result.
runQuery01_ :: (IsSQL sql, MonadDB m, MonadThrow m) => sql -> m ()
runQuery01_ :: forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m ()
runQuery01_ = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m Bool
runQuery01

----------------------------------------

-- | Specialization of 'runQuery' to 'SQL' type.
runSQL :: MonadDB m => SQL -> m Int
runSQL :: forall (m :: * -> *). MonadDB m => SQL -> m Int
runSQL = forall (m :: * -> *) sql. (MonadDB m, IsSQL sql) => sql -> m Int
runQuery

-- | Specialization of 'runQuery_' to 'SQL' type.
runSQL_ :: MonadDB m => SQL -> m ()
runSQL_ :: forall (m :: * -> *). MonadDB m => SQL -> m ()
runSQL_ = forall sql (m :: * -> *). (IsSQL sql, MonadDB m) => sql -> m ()
runQuery_

-- | Specialization of 'runQuery01' to 'SQL' type.
runSQL01 :: (MonadDB m, MonadThrow m) => SQL -> m Bool
runSQL01 :: forall (m :: * -> *). (MonadDB m, MonadThrow m) => SQL -> m Bool
runSQL01 = forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m Bool
runQuery01

-- | Specialization of 'runQuery01_' to 'SQL' type.
runSQL01_ :: (MonadDB m, MonadThrow m) => SQL -> m ()
runSQL01_ :: forall (m :: * -> *). (MonadDB m, MonadThrow m) => SQL -> m ()
runSQL01_ = forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
sql -> m ()
runQuery01_

----------------------------------------

-- | Specialization of 'runPreparedQuery' that discards the result.
runPreparedQuery_ :: (IsSQL sql, MonadDB m) => QueryName -> sql -> m ()
runPreparedQuery_ :: forall sql (m :: * -> *).
(IsSQL sql, MonadDB m) =>
QueryName -> sql -> m ()
runPreparedQuery_ QueryName
name = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) sql.
(MonadDB m, IsSQL sql) =>
QueryName -> sql -> m Int
runPreparedQuery QueryName
name

-- | Specialization of 'runPreparedQuery' that checks whether affected/returned
-- number of rows is in range [0, 1] and returns appropriate 'Bool' value.
-- Otherwise, 'AffectedRowsMismatch' exception is thrown.
runPreparedQuery01 :: (IsSQL sql, MonadDB m, MonadThrow m) => QueryName -> sql -> m Bool
runPreparedQuery01 :: forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
QueryName -> sql -> m Bool
runPreparedQuery01 QueryName
name sql
sql = do
  Int
n <- forall (m :: * -> *) sql.
(MonadDB m, IsSQL sql) =>
QueryName -> sql -> m Int
runPreparedQuery QueryName
name sql
sql
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a.
(Exception e, MonadDB m, MonadThrow m) =>
e -> m a
throwDB AffectedRowsMismatch {
    rowsExpected :: [(Int, Int)]
rowsExpected = [(Int
0, Int
1)]
  , rowsDelivered :: Int
rowsDelivered = Int
n
  }
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int
n forall a. Eq a => a -> a -> Bool
== Int
1

-- | Specialization of 'runPreparedQuery01' that discards the result.
runPreparedQuery01_ :: (IsSQL sql, MonadDB m, MonadThrow m) => QueryName -> sql -> m ()
runPreparedQuery01_ :: forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
QueryName -> sql -> m ()
runPreparedQuery01_ QueryName
name = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
QueryName -> sql -> m Bool
runPreparedQuery01 QueryName
name

----------------------------------------

-- | Specialization of 'runPreparedQuery' to 'SQL' type.
runPreparedSQL :: MonadDB m => QueryName -> SQL -> m Int
runPreparedSQL :: forall (m :: * -> *). MonadDB m => QueryName -> SQL -> m Int
runPreparedSQL = forall (m :: * -> *) sql.
(MonadDB m, IsSQL sql) =>
QueryName -> sql -> m Int
runPreparedQuery

-- | Specialization of 'runPreparedQuery_' to 'SQL' type.
runPreparedSQL_ :: MonadDB m => QueryName -> SQL -> m ()
runPreparedSQL_ :: forall (m :: * -> *). MonadDB m => QueryName -> SQL -> m ()
runPreparedSQL_ = forall sql (m :: * -> *).
(IsSQL sql, MonadDB m) =>
QueryName -> sql -> m ()
runPreparedQuery_

-- | Specialization of 'runPreparedQuery01' to 'SQL' type.
runPreparedSQL01 :: (MonadDB m, MonadThrow m) => QueryName -> SQL -> m Bool
runPreparedSQL01 :: forall (m :: * -> *).
(MonadDB m, MonadThrow m) =>
QueryName -> SQL -> m Bool
runPreparedSQL01 = forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
QueryName -> sql -> m Bool
runPreparedQuery01

-- | Specialization of 'runPreparedQuery01_' to 'SQL' type.
runPreparedSQL01_ :: (MonadDB m, MonadThrow m) => QueryName -> SQL -> m ()
runPreparedSQL01_ :: forall (m :: * -> *).
(MonadDB m, MonadThrow m) =>
QueryName -> SQL -> m ()
runPreparedSQL01_ = forall sql (m :: * -> *).
(IsSQL sql, MonadDB m, MonadThrow m) =>
QueryName -> sql -> m ()
runPreparedQuery01_