{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoFieldSelectors #-}
module Sq
(
Statement
, readStatement
, writeStatement
, SQL
, sql
, Input
, encode
, input
, Encode (..)
, encodeRefine
, EncodeDefault (..)
, encodeMaybe
, encodeEither
, encodeSizedIntegral
, encodeAeson
, encodeBinary
, encodeShow
, Output
, decode
, output
, Decode (..)
, decodeRefine
, DecodeDefault (..)
, decodeMaybe
, decodeEither
, decodeSizedIntegral
, decodeAeson
, decodeBinary
, decodeRead
, Name
, name
, Transactional
, read
, commit
, rollback
, embed
, Ref
, retry
, orElse
, one
, maybe
, zero
, some
, list
, fold
, foldM
, streamIO
, foldIO
, Pool
, readPool
, writePool
, tempPool
, subPool
, Settings (..)
, settings
, Transaction
, readTransaction
, commitTransaction
, rollbackTransaction
, new
, with
, uith
, Savepoint
, savepoint
, savepointRollback
, savepointRelease
, migrate
, migration
, Migration
, MigrationId
, MigrationsTable
, Retry (..)
, BindingName
, Mode (..)
, SubMode
, Null (..)
, ErrEncode (..)
, ErrInput (..)
, ErrDecode (..)
, ErrOutput (..)
, ErrStatement (..)
, ErrRows (..)
, S.SQLData (..)
, S.SQLVFS (..)
)
where
import Control.Exception.Safe qualified as Ex
import Control.Monad hiding (foldM)
import Control.Monad.IO.Class
import Control.Monad.Trans.Resource qualified as R
import Control.Monad.Trans.Resource.Extra qualified as R
import Data.Acquire qualified as A
import Data.Function
import Database.SQLite3 qualified as S
import Di.Df1 qualified as Di
import System.FilePath
import Prelude hiding (Read, maybe, read)
import Sq.Connection
import Sq.Decoders
import Sq.Encoders
import Sq.Input
import Sq.Migrations
import Sq.Mode
import Sq.Names
import Sq.Null
import Sq.Output
import Sq.Pool
import Sq.Statement
import Sq.Support
import Sq.Transactional
new :: (R.MonadResource m) => A.Acquire a -> m a
new :: forall (m :: * -> *) a. MonadResource m => Acquire a -> m a
new = ((ReleaseKey, a) -> a) -> m (ReleaseKey, a) -> m a
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ReleaseKey, a) -> a
forall a b. (a, b) -> b
snd (m (ReleaseKey, a) -> m a)
-> (Acquire a -> m (ReleaseKey, a)) -> Acquire a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Acquire a -> m (ReleaseKey, a)
forall (m :: * -> *) a.
MonadResource m =>
Acquire a -> m (ReleaseKey, a)
A.allocateAcquire
with :: (Ex.MonadMask m, MonadIO m) => A.Acquire a -> (a -> m b) -> m b
with :: forall (m :: * -> *) a b.
(MonadMask m, MonadIO m) =>
Acquire a -> (a -> m b) -> m b
with = Acquire a -> (a -> m b) -> m b
forall (m :: * -> *) a b.
(MonadMask m, MonadIO m) =>
Acquire a -> (a -> m b) -> m b
R.withAcquire
uith :: (R.MonadUnliftIO m) => A.Acquire a -> (a -> m b) -> m b
uith :: forall (m :: * -> *) a b.
MonadUnliftIO m =>
Acquire a -> (a -> m b) -> m b
uith = Acquire a -> (a -> m b) -> m b
forall (m :: * -> *) a b.
MonadUnliftIO m =>
Acquire a -> (a -> m b) -> m b
A.with
tempPool :: Di.Df1 -> A.Acquire (Pool Write)
tempPool :: Df1 -> Acquire (Pool 'Write)
tempPool Df1
di0 = do
FilePath
d <- Acquire FilePath
acquireTmpDir
SMode 'Write -> Df1 -> Settings -> Acquire (Pool 'Write)
forall (p :: Mode). SMode p -> Df1 -> Settings -> Acquire (Pool p)
pool SMode 'Write
SWrite (Segment -> Df1 -> Df1
forall level msg. Segment -> Di level Path msg -> Di level Path msg
Di.push Segment
"sq" Df1
di0) (Settings -> Acquire (Pool 'Write))
-> Settings -> Acquire (Pool 'Write)
forall a b. (a -> b) -> a -> b
$ FilePath -> Settings
settings (FilePath
d FilePath -> FilePath -> FilePath
</> FilePath
"db.sqlite")
writePool :: Di.Df1 -> Settings -> A.Acquire (Pool Write)
writePool :: Df1 -> Settings -> Acquire (Pool 'Write)
writePool Df1
di0 = SMode 'Write -> Df1 -> Settings -> Acquire (Pool 'Write)
forall (p :: Mode). SMode p -> Df1 -> Settings -> Acquire (Pool p)
pool SMode 'Write
SWrite (Segment -> Df1 -> Df1
forall level msg. Segment -> Di level Path msg -> Di level Path msg
Di.push Segment
"sq" Df1
di0)
{-# INLINE writePool #-}
readPool :: Di.Df1 -> Settings -> A.Acquire (Pool Read)
readPool :: Df1 -> Settings -> Acquire (Pool 'Read)
readPool Df1
di0 = SMode 'Read -> Df1 -> Settings -> Acquire (Pool 'Read)
forall (p :: Mode). SMode p -> Df1 -> Settings -> Acquire (Pool p)
pool SMode 'Read
SRead (Segment -> Df1 -> Df1
forall level msg. Segment -> Di level Path msg -> Di level Path msg
Di.push Segment
"sq" Df1
di0)
{-# INLINE readPool #-}
read
:: (MonadIO m, SubMode p 'Read)
=> Pool p
-> (forall g. Transactional g 'Retry 'Read a)
-> m a
read :: forall {k} (m :: * -> *) (p :: Mode) a.
(MonadIO m, SubMode p 'Read) =>
Pool p -> (forall (g :: k). Transactional g 'Retry 'Read a) -> m a
read Pool p
p = Acquire (Transaction 'Read)
-> (forall {g :: k}. Transactional g 'Retry 'Read a) -> m a
forall {k} (m :: * -> *) (r :: Retry) (t :: Mode) a.
MonadIO m =>
Acquire (Transaction t)
-> (forall (g :: k). Transactional g r t a) -> m a
transactionalRetry (Acquire (Transaction 'Read)
-> (forall {g :: k}. Transactional g 'Retry 'Read a) -> m a)
-> Acquire (Transaction 'Read)
-> (forall {g :: k}. Transactional g 'Retry 'Read a)
-> m a
forall a b. (a -> b) -> a -> b
$ Pool p -> Acquire (Transaction 'Read)
forall (mode :: Mode). Pool mode -> Acquire (Transaction 'Read)
readTransaction Pool p
p
{-# INLINE read #-}
commit
:: (MonadIO m)
=> Pool 'Write
-> (forall g. Transactional g 'Retry 'Write a)
-> m a
commit :: forall {k} (m :: * -> *) a.
MonadIO m =>
Pool 'Write
-> (forall (g :: k). Transactional g 'Retry 'Write a) -> m a
commit Pool 'Write
p = Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a) -> m a
forall {k} (m :: * -> *) (r :: Retry) (t :: Mode) a.
MonadIO m =>
Acquire (Transaction t)
-> (forall (g :: k). Transactional g r t a) -> m a
transactionalRetry (Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a) -> m a)
-> Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a)
-> m a
forall a b. (a -> b) -> a -> b
$ Pool 'Write -> Acquire (Transaction 'Write)
commitTransaction Pool 'Write
p
{-# INLINE commit #-}
rollback
:: (MonadIO m)
=> Pool 'Write
-> (forall g. Transactional g 'Retry 'Write a)
-> m a
rollback :: forall {k} (m :: * -> *) a.
MonadIO m =>
Pool 'Write
-> (forall (g :: k). Transactional g 'Retry 'Write a) -> m a
rollback Pool 'Write
p = Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a) -> m a
forall {k} (m :: * -> *) (r :: Retry) (t :: Mode) a.
MonadIO m =>
Acquire (Transaction t)
-> (forall (g :: k). Transactional g r t a) -> m a
transactionalRetry (Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a) -> m a)
-> Acquire (Transaction 'Write)
-> (forall {g :: k}. Transactional g 'Retry 'Write a)
-> m a
forall a b. (a -> b) -> a -> b
$ Pool 'Write -> Acquire (Transaction 'Write)
rollbackTransaction Pool 'Write
p
{-# INLINE rollback #-}