module Database.PostgreSQL.PQTypes.Class
  ( -- * Class
    MonadDB (..)

    -- * Misc
  , BackendPid (..)
  , QueryName (..)
  ) where

import Control.Monad.Trans
import Control.Monad.Trans.Control
import GHC.Stack

import Database.PostgreSQL.PQTypes.FromRow
import Database.PostgreSQL.PQTypes.Internal.BackendPid
import Database.PostgreSQL.PQTypes.Internal.Connection
import Database.PostgreSQL.PQTypes.Internal.Notification
import Database.PostgreSQL.PQTypes.Internal.QueryResult
import Database.PostgreSQL.PQTypes.SQL.Class
import Database.PostgreSQL.PQTypes.Transaction.Settings

class (Applicative m, Monad m) => MonadDB m where
  -- | Run SQL query and return number of affected/returned rows. Note that
  -- for a given connection, only one thread may be executing 'runQuery' at
  -- a given time. If simultaneous call is made from another thread, it
  -- will block until currently running 'runQuery' finishes.
  runQuery :: (HasCallStack, IsSQL sql) => sql -> m Int

  -- | Similar to 'runQuery', but it prepares and executes a statement under a
  -- given name.
  runPreparedQuery :: (HasCallStack, IsSQL sql) => QueryName -> sql -> m Int

  -- | Get last SQL query that was executed and ID of the server process
  -- attached to the session that executed it.
  getLastQuery :: m (BackendPid, SomeSQL)

  -- | Subsequent queries in the callback do not alter the result of
  -- 'getLastQuery'.
  withFrozenLastQuery :: m a -> m a

  -- | Get current connection statistics.
  getConnectionStats :: m ConnectionStats

  -- | Get current query result.
  getQueryResult :: FromRow row => m (Maybe (QueryResult row))

  -- | Clear current query result.
  clearQueryResult :: m ()

  -- | Get current connection acquisition mode.
  getConnectionAcquisitionMode :: HasCallStack => m ConnectionAcquisitionMode

  -- | Acquire and hold a connection with a given isolation level and
  -- permissions.
  --
  -- If the connection is already held, a check is performed if the isolation
  -- level and permissions are the same as the ones currently in place. If so,
  -- nothing happens, otherwise an error is thrown.
  acquireAndHoldConnection :: HasCallStack => IsolationLevel -> Permissions -> m ()

  -- | Unsafely switch to the 'AcquireOnDemand' mode.
  --
  -- This function is unsafe because if a connection is already held, the
  -- transaction in progress is commited, so atomicity guarantee is lost.
  unsafeAcquireOnDemandConnection :: HasCallStack => m ()

  -- | Attempt to receive a notification from the server. This
  -- function waits until a notification arrives or specified
  -- number of microseconds has passed. If a negative number
  -- of microseconds is passed as an argument, it will wait
  -- indefinitely. In addition, there are a couple of things
  -- to be aware of:
  --
  -- * A lock on the underlying database connection is acquired
  -- for the duration of the function.
  --
  -- * Notifications can be received only between transactions
  -- (see <http://www.postgresql.org/docs/current/static/sql-notify.html>
  -- for further info), therefore calling this function within
  -- a transaction block will return 'Just' only if notifications
  -- were received before the transaction began.
  getNotification :: HasCallStack => Int -> m (Maybe Notification)

  -- | Execute supplied monadic action with new connection
  -- using current connection source and transaction settings.
  --
  -- Particularly useful when you want to spawn a new thread, but
  -- do not want the connection in child thread to be shared with
  -- the parent one.
  withNewConnection :: HasCallStack => m a -> m a

-- | Generic, overlappable instance.
instance
  {-# OVERLAPPABLE #-}
  ( Applicative (t m)
  , Monad (t m)
  , MonadTrans t
  , MonadTransControl t
  , MonadDB m
  )
  => MonadDB (t m)
  where
  runQuery :: forall sql. (HasCallStack, IsSQL sql) => sql -> t m Int
runQuery = (HasCallStack => sql -> t m Int) -> sql -> t m Int
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => sql -> t m Int) -> sql -> t m Int)
-> (HasCallStack => sql -> t m Int) -> sql -> t m Int
forall a b. (a -> b) -> a -> b
$ m Int -> t m Int
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m Int -> t m Int) -> (sql -> m Int) -> sql -> t m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. sql -> m Int
forall sql. (HasCallStack, IsSQL sql) => sql -> m Int
forall (m :: * -> *) sql.
(MonadDB m, HasCallStack, IsSQL sql) =>
sql -> m Int
runQuery
  runPreparedQuery :: forall sql.
(HasCallStack, IsSQL sql) =>
QueryName -> sql -> t m Int
runPreparedQuery QueryName
name = (HasCallStack => sql -> t m Int) -> sql -> t m Int
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => sql -> t m Int) -> sql -> t m Int)
-> (HasCallStack => sql -> t m Int) -> sql -> t m Int
forall a b. (a -> b) -> a -> b
$ m Int -> t m Int
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m Int -> t m Int) -> (sql -> m Int) -> sql -> t m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryName -> sql -> m Int
forall sql. (HasCallStack, IsSQL sql) => QueryName -> sql -> m Int
forall (m :: * -> *) sql.
(MonadDB m, HasCallStack, IsSQL sql) =>
QueryName -> sql -> m Int
runPreparedQuery QueryName
name
  getLastQuery :: t m (BackendPid, SomeSQL)
getLastQuery = m (BackendPid, SomeSQL) -> t m (BackendPid, SomeSQL)
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m (BackendPid, SomeSQL)
forall (m :: * -> *). MonadDB m => m (BackendPid, SomeSQL)
getLastQuery
  withFrozenLastQuery :: forall a. t m a -> t m a
withFrozenLastQuery t m a
m = (Run t -> m (StT t a)) -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTransControl t, Monad (t m), Monad m) =>
(Run t -> m (StT t a)) -> t m a
controlT ((Run t -> m (StT t a)) -> t m a)
-> (Run t -> m (StT t a)) -> t m a
forall a b. (a -> b) -> a -> b
$ \Run t
run -> m (StT t a) -> m (StT t a)
forall a. m a -> m a
forall (m :: * -> *) a. MonadDB m => m a -> m a
withFrozenLastQuery (t m a -> m (StT t a)
Run t
run t m a
m)
  getConnectionStats :: t m ConnectionStats
getConnectionStats = m ConnectionStats -> t m ConnectionStats
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m ConnectionStats
forall (m :: * -> *). MonadDB m => m ConnectionStats
getConnectionStats
  getQueryResult :: forall row. FromRow row => t m (Maybe (QueryResult row))
getQueryResult = m (Maybe (QueryResult row)) -> t m (Maybe (QueryResult row))
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m (Maybe (QueryResult row))
forall row. FromRow row => m (Maybe (QueryResult row))
forall (m :: * -> *) row.
(MonadDB m, FromRow row) =>
m (Maybe (QueryResult row))
getQueryResult
  clearQueryResult :: t m ()
clearQueryResult = m () -> t m ()
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m ()
forall (m :: * -> *). MonadDB m => m ()
clearQueryResult
  getConnectionAcquisitionMode :: HasCallStack => t m ConnectionAcquisitionMode
getConnectionAcquisitionMode = m ConnectionAcquisitionMode -> t m ConnectionAcquisitionMode
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m ConnectionAcquisitionMode
forall (m :: * -> *).
(MonadDB m, HasCallStack) =>
m ConnectionAcquisitionMode
getConnectionAcquisitionMode
  acquireAndHoldConnection :: HasCallStack => IsolationLevel -> Permissions -> t m ()
acquireAndHoldConnection IsolationLevel
isoLevel = m () -> t m ()
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> t m ()) -> (Permissions -> m ()) -> Permissions -> t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IsolationLevel -> Permissions -> m ()
forall (m :: * -> *).
(MonadDB m, HasCallStack) =>
IsolationLevel -> Permissions -> m ()
acquireAndHoldConnection IsolationLevel
isoLevel
  unsafeAcquireOnDemandConnection :: HasCallStack => t m ()
unsafeAcquireOnDemandConnection = m () -> t m ()
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m ()
forall (m :: * -> *). (MonadDB m, HasCallStack) => m ()
unsafeAcquireOnDemandConnection
  getNotification :: HasCallStack => Int -> t m (Maybe Notification)
getNotification = m (Maybe Notification) -> t m (Maybe Notification)
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe Notification) -> t m (Maybe Notification))
-> (Int -> m (Maybe Notification))
-> Int
-> t m (Maybe Notification)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> m (Maybe Notification)
forall (m :: * -> *).
(MonadDB m, HasCallStack) =>
Int -> m (Maybe Notification)
getNotification
  withNewConnection :: forall a. HasCallStack => t m a -> t m a
withNewConnection t m a
m = (Run t -> m (StT t a)) -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTransControl t, Monad (t m), Monad m) =>
(Run t -> m (StT t a)) -> t m a
controlT ((Run t -> m (StT t a)) -> t m a)
-> (Run t -> m (StT t a)) -> t m a
forall a b. (a -> b) -> a -> b
$ \Run t
run -> m (StT t a) -> m (StT t a)
forall a. HasCallStack => m a -> m a
forall (m :: * -> *) a. (MonadDB m, HasCallStack) => m a -> m a
withNewConnection (t m a -> m (StT t a)
Run t
run t m a
m)