Database.Persist.Sqlite

persistent-sqlite-2.13.3.0: Backend for the persistent library using sqlite3.

Safe Haskell | None
Language | Haskell2010

Database.Persist.Sqlite

Description

A sqlite backend for persistent.

Note: If you prepend `WAL=off` to your connection string, it will disable the write-ahead log. This functionality is now deprecated in favour of using SqliteConnectionInfo.

Synopsis

- withSqlitePool :: (MonadUnliftIO m, MonadLoggerIO m) => Text -> Int -> (Pool SqlBackend -> m a) -> m a
- withSqlitePoolInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> Int -> (Pool SqlBackend -> m a) -> m a
- withSqliteConn :: (MonadUnliftIO m, MonadLoggerIO m) => Text -> (SqlBackend -> m a) -> m a
- withSqliteConnInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> (SqlBackend -> m a) -> m a
- createSqlitePool :: (MonadLoggerIO m, MonadUnliftIO m) => Text -> Int -> m (Pool SqlBackend)
- createSqlitePoolFromInfo :: (MonadLoggerIO m, MonadUnliftIO m) => SqliteConnectionInfo -> Int -> m (Pool SqlBackend)
- createSqlitePoolWithConfig :: (MonadUnliftIO m, MonadLoggerIO m) => Text -> ConnectionPoolConfig -> m (Pool SqlBackend)
- module Database.Persist.Sql
- data SqliteConf
  - = SqliteConf {
    - sqlDatabase :: Text
    - sqlPoolSize :: Int
    }
  - | SqliteConfInfo {
    - sqlConnInfo :: SqliteConnectionInfo
    - sqlPoolSize :: Int
    }
- data SqliteConnectionInfo
- mkSqliteConnectionInfo :: Text -> SqliteConnectionInfo
- sqlConnectionStr :: Lens' SqliteConnectionInfo Text
- walEnabled :: Lens' SqliteConnectionInfo Bool
- fkEnabled :: Lens' SqliteConnectionInfo Bool
- extraPragmas :: Lens' SqliteConnectionInfo [Text]
- runSqlite :: MonadUnliftIO m => Text -> ReaderT SqlBackend (NoLoggingT (ResourceT m)) a -> m a
- runSqliteInfo :: MonadUnliftIO m => SqliteConnectionInfo -> ReaderT SqlBackend (NoLoggingT (ResourceT m)) a -> m a
- wrapConnection :: Connection -> LogFunc -> IO SqlBackend
- wrapConnectionInfo :: SqliteConnectionInfo -> Connection -> LogFunc -> IO SqlBackend
- mockMigration :: Migration -> IO ()
- retryOnBusy :: (MonadUnliftIO m, MonadLoggerIO m) => m a -> m a
- waitForDatabase :: forall (m :: Type -> Type) backend. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => ReaderT backend m ()
- data ForeignKeyViolation = ForeignKeyViolation {
  - foreignKeyTable :: Text
  - foreignKeyColumn :: Text
  - foreignKeyRowId :: Int64
  }
- checkForeignKeys :: forall (m :: Type -> Type) env. (MonadResource m, MonadReader env m, BackendCompatible SqlBackend env) => ConduitM () ForeignKeyViolation m ()
- data RawSqlite backend
- openRawSqliteConn :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> m (RawSqlite SqlBackend)
- persistentBackend :: forall backend1 backend2 f. Functor f => (backend1 -> f backend2) -> RawSqlite backend1 -> f (RawSqlite backend2)
- rawSqliteConnection :: forall backend f. Functor f => (Connection -> f Connection) -> RawSqlite backend -> f (RawSqlite backend)
- withRawSqliteConnInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> (RawSqlite SqlBackend -> m a) -> m a
- createRawSqlitePoolFromInfo :: (MonadLoggerIO m, MonadUnliftIO m) => SqliteConnectionInfo -> (RawSqlite SqlBackend -> m ()) -> Int -> m (Pool (RawSqlite SqlBackend))
- createRawSqlitePoolFromInfo_ :: (MonadLoggerIO m, MonadUnliftIO m) => SqliteConnectionInfo -> Int -> m (Pool (RawSqlite SqlBackend))
- withRawSqlitePoolInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> (RawSqlite SqlBackend -> m ()) -> Int -> (Pool (RawSqlite SqlBackend) -> m a) -> m a
- withRawSqlitePoolInfo_ :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> Int -> (Pool (RawSqlite SqlBackend) -> m a) -> m a

# Documentation

withSqlitePool #

Arguments

:: (MonadUnliftIO m, MonadLoggerIO m) |
=> Text |
-> Int | number of connections to open
-> (Pool SqlBackend -> m a) |
-> m a |

Run the given action with a connection pool.

Like `createSqlitePool`, this should not be used with `:memory:`.

withSqlitePoolInfo #

Arguments

:: (MonadUnliftIO m, MonadLoggerIO m) |
=> SqliteConnectionInfo |
-> Int | number of connections to open
-> (Pool SqlBackend -> m a) |
-> m a |

Run the given action with a connection pool.

Like `createSqlitePool`, this should not be used with `:memory:`.

Since: 2.6.2

withSqliteConn :: (MonadUnliftIO m, MonadLoggerIO m) => Text -> (SqlBackend -> m a) -> m a #

withSqliteConnInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> (SqlBackend -> m a) -> m a #

Since: 2.6.2

createSqlitePool :: (MonadLoggerIO m, MonadUnliftIO m) => Text -> Int -> m (Pool SqlBackend) #

Create a pool of SQLite connections.

Note that this should not be used with the `:memory:` connection string, as the pool will regularly remove connections, destroying your database. Instead, use `withSqliteConn`.

createSqlitePoolFromInfo :: (MonadLoggerIO m, MonadUnliftIO m) => SqliteConnectionInfo -> Int -> m (Pool SqlBackend) #

Create a pool of SQLite connections.

Note that this should not be used with the `:memory:` connection string, as the pool will regularly remove connections, destroying your database. Instead, use `withSqliteConn`.

Since: 2.6.2

createSqlitePoolWithConfig #

Arguments

:: (MonadUnliftIO m, MonadLoggerIO m) |
=> Text | connection string
-> ConnectionPoolConfig |
-> m (Pool SqlBackend) |

Create a pool of SQLite connections.

Since: 2.13.4.0

module Database.Persist.Sql

data SqliteConf #

Information required to setup a connection pool.

Constructors

SqliteConf |
Fields sqlDatabase :: Text sqlPoolSize :: Int
SqliteConfInfo |
Fields sqlConnInfo :: SqliteConnectionInfo sqlPoolSize :: Int

#### Instances

Instances details

FromJSON SqliteConf # |
Instance details Defined in Database.Persist.Sqlite Methods parseJSON :: Value -> Parser SqliteConf # parseJSONList :: Value -> Parser [SqliteConf] # omittedField :: Maybe SqliteConf #
Show SqliteConf # |
Instance details Defined in Database.Persist.Sqlite Methods showsPrec :: Int -> SqliteConf -> ShowS # show :: SqliteConf -> String # showList :: [SqliteConf] -> ShowS #
PersistConfig SqliteConf # |
Instance details Defined in Database.Persist.Sqlite Associated Types
type PersistConfigBackend SqliteConf |
Instance details Defined in Database.Persist.Sqlite type PersistConfigBackend SqliteConf = SqlPersistT
type PersistConfigPool SqliteConf |
Instance details Defined in Database.Persist.Sqlite type PersistConfigPool SqliteConf = ConnectionPool
Methods loadConfig :: Value -> Parser SqliteConf # applyEnv :: SqliteConf -> IO SqliteConf # createPoolConfig :: SqliteConf -> IO (PersistConfigPool SqliteConf) # runPool :: MonadUnliftIO m => SqliteConf -> PersistConfigBackend SqliteConf m a -> PersistConfigPool SqliteConf -> m a #
type PersistConfigBackend SqliteConf # |
Instance details Defined in Database.Persist.Sqlite type PersistConfigBackend SqliteConf = SqlPersistT
type PersistConfigPool SqliteConf # |
Instance details Defined in Database.Persist.Sqlite type PersistConfigPool SqliteConf = ConnectionPool

data SqliteConnectionInfo #

Information required to connect to a sqlite database. We export lenses instead of fields to avoid being limited to the current implementation.

Since: 2.6.2

#### Instances

Instances details

FromJSON SqliteConnectionInfo # |
Instance details Defined in Database.Persist.Sqlite Methods parseJSON :: Value -> Parser SqliteConnectionInfo # parseJSONList :: Value -> Parser [SqliteConnectionInfo] # omittedField :: Maybe SqliteConnectionInfo #
Show SqliteConnectionInfo # |
Instance details Defined in Database.Persist.Sqlite Methods showsPrec :: Int -> SqliteConnectionInfo -> ShowS # show :: SqliteConnectionInfo -> String # showList :: [SqliteConnectionInfo] -> ShowS #

mkSqliteConnectionInfo :: Text -> SqliteConnectionInfo #

Creates a SqliteConnectionInfo from a connection string, with the default settings.

Since: 2.6.2

sqlConnectionStr :: Lens' SqliteConnectionInfo Text #

walEnabled :: Lens' SqliteConnectionInfo Bool #

fkEnabled :: Lens' SqliteConnectionInfo Bool #

extraPragmas :: Lens' SqliteConnectionInfo [Text] #

runSqlite #

Arguments

:: MonadUnliftIO m |
=> Text | connection string
-> ReaderT SqlBackend (NoLoggingT (ResourceT m)) a | database action
-> m a |

A convenience helper which creates a new database connection and runs the given block, handling `MonadResource` and `MonadLogger` requirements. Note that all log messages are discarded.

Since: 1.1.4

runSqliteInfo #

Arguments

:: MonadUnliftIO m |
=> SqliteConnectionInfo |
-> ReaderT SqlBackend (NoLoggingT (ResourceT m)) a | database action
-> m a |

A convenience helper which creates a new database connection and runs the given block, handling `MonadResource` and `MonadLogger` requirements. Note that all log messages are discarded.

Since: 2.6.2

wrapConnection :: Connection -> LogFunc -> IO SqlBackend #

Wrap up a raw `Connection` as a Persistent SQL `Connection`.

### Example usage

Expand

    {-# LANGUAGE GADTs #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TemplateHaskell #-}
    {-# LANGUAGE QuasiQuotes #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

    import Control.Monad.IO.Class  (liftIO)
    import Database.Persist
    import Database.Sqlite
    import Database.Persist.Sqlite
    import Database.Persist.TH

    share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
    Person
      name String
      age Int Maybe
      deriving Show
    |]

    main :: IO ()
    main = do
      conn <- open "/home/sibi/test.db"
      (backend :: SqlBackend) <- wrapConnection conn (\_ _ _ _ -> return ())
      flip runSqlPersistM backend $ do
             runMigration migrateAll
             insert_ $ Person "John doe" $ Just 35
             insert_ $ Person "Hema" $ Just 36
             (pers :: [Entity Person]) <- selectList [] []
             liftIO $ print pers
      close' backend

On executing it, you get this output:

    Migrating: CREATE TABLE "person"("id" INTEGER PRIMARY KEY,"name" VARCHAR NOT NULL,"age" INTEGER NULL)
    [Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 1}}, entityVal = Person {personName = "John doe", personAge = Just 35}},Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 2}}, entityVal = Person {personName = "Hema", personAge = Just 36}}]

Since: 1.1.5

wrapConnectionInfo :: SqliteConnectionInfo -> Connection -> LogFunc -> IO SqlBackend #

Wrap up a raw `Connection` as a Persistent SQL `Connection`, allowing full control over WAL and FK constraints.

Since: 2.6.2

mockMigration :: Migration -> IO () #

Mock a migration even when the database is not present. This function performs the same functionality of `printMigration` with the difference that an actual database isn't needed for it.

retryOnBusy :: (MonadUnliftIO m, MonadLoggerIO m) => m a -> m a #

Retry if a Busy is thrown, following an exponential backoff strategy.

Since: 2.9.3

waitForDatabase :: forall (m :: Type -> Type) backend. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => ReaderT backend m () #

Wait until some noop action on the database does not return an `ErrorBusy`. See `retryOnBusy`.

Since: 2.9.3

data ForeignKeyViolation #

Data type for reporting foreign key violations using `checkForeignKeys`.

Since: 2.11.1

Constructors

ForeignKeyViolation |
Fields foreignKeyTable :: Text The table of the violated constraint foreignKeyColumn :: Text The column of the violated constraint foreignKeyRowId :: Int64 The ROWID of the row with the violated foreign key constraint

#### Instances

Instances details

Show ForeignKeyViolation # |
Instance details Defined in Database.Persist.Sqlite Methods showsPrec :: Int -> ForeignKeyViolation -> ShowS # show :: ForeignKeyViolation -> String # showList :: [ForeignKeyViolation] -> ShowS #
Eq ForeignKeyViolation # |
Instance details Defined in Database.Persist.Sqlite Methods (==) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool # (/=) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool #
Ord ForeignKeyViolation # |
Instance details Defined in Database.Persist.Sqlite Methods compare :: ForeignKeyViolation -> ForeignKeyViolation -> Ordering # (<) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool # (<=) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool # (>) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool # (>=) :: ForeignKeyViolation -> ForeignKeyViolation -> Bool # max :: ForeignKeyViolation -> ForeignKeyViolation -> ForeignKeyViolation # min :: ForeignKeyViolation -> ForeignKeyViolation -> ForeignKeyViolation #

checkForeignKeys :: forall (m :: Type -> Type) env. (MonadResource m, MonadReader env m, BackendCompatible SqlBackend env) => ConduitM () ForeignKeyViolation m () #

Outputs all (if any) the violated foreign key constraints in the database.

The main use is to validate that no foreign key constraints were broken/corrupted by anyone operating on the database with foreign keys disabled. See `fkEnabled`.

Since: 2.11.1

data RawSqlite backend #

Wrapper for persistent SqlBackends that carry the corresponding `Connection`.

Since: 2.10.2

#### Instances

Instances details

BackendCompatible b (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods projectBackend :: RawSqlite b -> b #
(PersistCore b, PersistCore (RawSqlite b), FromJSON (BackendKey b)) => FromJSON (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods parseJSON :: Value -> Parser (BackendKey (RawSqlite b)) # parseJSONList :: Value -> Parser [BackendKey (RawSqlite b)] # omittedField :: Maybe (BackendKey (RawSqlite b)) #
(PersistCore b, PersistCore (RawSqlite b), ToJSON (BackendKey b)) => ToJSON (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods toJSON :: BackendKey (RawSqlite b) -> Value # toEncoding :: BackendKey (RawSqlite b) -> Encoding # toJSONList :: [BackendKey (RawSqlite b)] -> Value # toEncodingList :: [BackendKey (RawSqlite b)] -> Encoding # omitField :: BackendKey (RawSqlite b) -> Bool #
(PersistCore b, PersistCore (RawSqlite b), Bounded (BackendKey b)) => Bounded (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods minBound :: BackendKey (RawSqlite b) # maxBound :: BackendKey (RawSqlite b) #
(PersistCore b, PersistCore (RawSqlite b), Enum (BackendKey b)) => Enum (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods succ :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # pred :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # toEnum :: Int -> BackendKey (RawSqlite b) # fromEnum :: BackendKey (RawSqlite b) -> Int # enumFrom :: BackendKey (RawSqlite b) -> [BackendKey (RawSqlite b)] # enumFromThen :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> [BackendKey (RawSqlite b)] # enumFromTo :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> [BackendKey (RawSqlite b)] # enumFromThenTo :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> [BackendKey (RawSqlite b)] #
(PersistCore b, PersistCore (RawSqlite b), Num (BackendKey b)) => Num (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods (+) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # (-) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # (*) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # negate :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # abs :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # signum :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # fromInteger :: Integer -> BackendKey (RawSqlite b) #
(PersistCore b, PersistCore (RawSqlite b), Read (BackendKey b)) => Read (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods readsPrec :: Int -> ReadS (BackendKey (RawSqlite b)) # readList :: ReadS [BackendKey (RawSqlite b)] # readPrec :: ReadPrec (BackendKey (RawSqlite b)) # readListPrec :: ReadPrec [BackendKey (RawSqlite b)] #
(PersistCore b, PersistCore (RawSqlite b), Integral (BackendKey b)) => Integral (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods quot :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # rem :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # div :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # mod :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # quotRem :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> (BackendKey (RawSqlite b), BackendKey (RawSqlite b)) # divMod :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> (BackendKey (RawSqlite b), BackendKey (RawSqlite b)) # toInteger :: BackendKey (RawSqlite b) -> Integer #
(PersistCore b, PersistCore (RawSqlite b), Real (BackendKey b)) => Real (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods toRational :: BackendKey (RawSqlite b) -> Rational #
(PersistCore b, PersistCore (RawSqlite b), Show (BackendKey b)) => Show (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods showsPrec :: Int -> BackendKey (RawSqlite b) -> ShowS # show :: BackendKey (RawSqlite b) -> String # showList :: [BackendKey (RawSqlite b)] -> ShowS #
(PersistCore b, PersistCore (RawSqlite b), Eq (BackendKey b)) => Eq (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods (==) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool # (/=) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool #
(PersistCore b, PersistCore (RawSqlite b), Ord (BackendKey b)) => Ord (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods compare :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Ordering # (<) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool # (<=) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool # (>) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool # (>=) :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> Bool # max :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) # min :: BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) -> BackendKey (RawSqlite b) #
(PersistCore b, PersistCore (RawSqlite b), PersistField (BackendKey b)) => PersistField (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods toPersistValue :: BackendKey (RawSqlite b) -> PersistValue # fromPersistValue :: PersistValue -> Either Text (BackendKey (RawSqlite b)) #
(HasPersistBackend b, PersistQueryRead b) => PersistQueryRead (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistRecordBackend record (RawSqlite b), MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT (RawSqlite b) m1 (Acquire (ConduitM () (Entity record) m2 ())) # selectFirst :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> [SelectOpt record] -> ReaderT (RawSqlite b) m (Maybe (Entity record)) # selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (MonadIO m1, MonadIO m2, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> [SelectOpt record] -> ReaderT (RawSqlite b) m1 (Acquire (ConduitM () (Key record) m2 ())) # count :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> ReaderT (RawSqlite b) m Int # exists :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> ReaderT (RawSqlite b) m Bool #
(HasPersistBackend b, PersistQueryWrite b) => PersistQueryWrite (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods updateWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> [Update record] -> ReaderT (RawSqlite b) m () # deleteWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Filter record] -> ReaderT (RawSqlite b) m () #
HasPersistBackend b => HasPersistBackend (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Associated Types
type BaseBackend (RawSqlite b0) |
Instance details Defined in Database.Persist.Sqlite type BaseBackend (RawSqlite b0) = BaseBackend (Compatible b0 (RawSqlite b0))
Methods persistBackend :: RawSqlite b -> BaseBackend (RawSqlite b) #
PersistCore b => PersistCore (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Associated Types
newtype BackendKey (RawSqlite b) |
Instance details Defined in Database.Persist.Sqlite newtype BackendKey (RawSqlite b) = RawSqliteKey { unRawSqliteKey :: BackendKey (Compatible b (RawSqlite b)) }
(HasPersistBackend b, PersistStoreRead b) => PersistStoreRead (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods get :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> ReaderT (RawSqlite b) m (Maybe record) # getMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Key record] -> ReaderT (RawSqlite b) m (Map (Key record) record) #
(HasPersistBackend b, PersistStoreWrite b) => PersistStoreWrite (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods insert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => record -> ReaderT (RawSqlite b) m (Key record) # insert_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => record -> ReaderT (RawSqlite b) m () # insertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => [record] -> ReaderT (RawSqlite b) m [Key record] # insertMany_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => [record] -> ReaderT (RawSqlite b) m () # insertEntityMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [Entity record] -> ReaderT (RawSqlite b) m () # insertKey :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> record -> ReaderT (RawSqlite b) m () # repsert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> record -> ReaderT (RawSqlite b) m () # repsertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => [(Key record, record)] -> ReaderT (RawSqlite b) m () # replace :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> record -> ReaderT (RawSqlite b) m () # delete :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> ReaderT (RawSqlite b) m () # update :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> [Update record] -> ReaderT (RawSqlite b) m () # updateGet :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Key record -> [Update record] -> ReaderT (RawSqlite b) m record #
(HasPersistBackend b, PersistUniqueRead b) => PersistUniqueRead (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods getBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Unique record -> ReaderT (RawSqlite b) m (Maybe (Entity record)) # existsBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Unique record -> ReaderT (RawSqlite b) m Bool #
(HasPersistBackend b, PersistUniqueWrite b) => PersistUniqueWrite (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite Methods deleteBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b)) => Unique record -> ReaderT (RawSqlite b) m () # insertUnique :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => record -> ReaderT (RawSqlite b) m (Maybe (Key record)) # insertUnique_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => record -> ReaderT (RawSqlite b) m (Maybe ()) # upsert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> ReaderT (RawSqlite b) m (Entity record) # upsertBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => Unique record -> record -> [Update record] -> ReaderT (RawSqlite b) m (Entity record) # putMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record (RawSqlite b), SafeToInsert record) => [record] -> ReaderT (RawSqlite b) m () #
(PersistCore b, PersistCore (RawSqlite b), PersistFieldSql (BackendKey b)) => PersistFieldSql (BackendKey (RawSqlite b)) # |
Instance details Defined in Database.Persist.Sqlite Methods sqlType :: Proxy (BackendKey (RawSqlite b)) -> SqlType #
newtype BackendKey (RawSqlite b) # |
Instance details Defined in Database.Persist.Sqlite newtype BackendKey (RawSqlite b) = RawSqliteKey { unRawSqliteKey :: BackendKey (Compatible b (RawSqlite b)) }
type BaseBackend (RawSqlite b0) # |
Instance details Defined in Database.Persist.Sqlite type BaseBackend (RawSqlite b0) = BaseBackend (Compatible b0 (RawSqlite b0))

openRawSqliteConn :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> m (RawSqlite SqlBackend) #

Open a ``RawSqlite` `SqlBackend`` connection from a `SqliteConnectionInfo`.

When using this function, the caller has to accept the responsibility of cleaning up the resulting connection. To do this, use `close` with the `rawSqliteConnection` - it's enough to simply drop the `persistBackend` afterwards.

Since: 2.13.2

persistentBackend :: forall backend1 backend2 f. Functor f => (backend1 -> f backend2) -> RawSqlite backend1 -> f (RawSqlite backend2) #

rawSqliteConnection :: forall backend f. Functor f => (Connection -> f Connection) -> RawSqlite backend -> f (RawSqlite backend) #

withRawSqliteConnInfo :: (MonadUnliftIO m, MonadLoggerIO m) => SqliteConnectionInfo -> (RawSqlite SqlBackend -> m a) -> m a #

Like `withSqliteConnInfo`, but exposes the internal `Connection`. For power users who want to manually interact with SQLite's C API via internals exposed by Database.Sqlite.Internal

Since: 2.10.2

createRawSqlitePoolFromInfo #

Arguments

:: (MonadLoggerIO m, MonadUnliftIO m) |
=> SqliteConnectionInfo |
-> (RawSqlite SqlBackend -> m ()) | An action that is run whenever a new `RawSqlite` connection is allocated in the pool. The main use of this function is to register custom functions with the SQLite connection upon creation.
-> Int |
-> m (Pool (RawSqlite SqlBackend)) |

Like `createSqlitePoolFromInfo`, but like `withRawSqliteConnInfo` it exposes the internal `Connection`.

For power users who want to manually interact with SQLite's C API via internals exposed by Database.Sqlite.Internal. The callback can be used to run arbitrary actions on the connection upon allocation from the pool.

Since: 2.10.6

createRawSqlitePoolFromInfo_ :: (MonadLoggerIO m, MonadUnliftIO m) => SqliteConnectionInfo -> Int -> m (Pool (RawSqlite SqlBackend)) #

Like `createRawSqlitePoolFromInfo`, but doesn't require a callback operating on the connection.

Since: 2.10.6

withRawSqlitePoolInfo #

Arguments

:: (MonadUnliftIO m, MonadLoggerIO m) |
=> SqliteConnectionInfo |
-> (RawSqlite SqlBackend -> m ()) |
-> Int | number of connections to open
-> (Pool (RawSqlite SqlBackend) -> m a) |
-> m a |

Like `createSqlitePoolInfo`, but based on `createRawSqlitePoolFromInfo`.

Since: 2.10.6

withRawSqlitePoolInfo_ #

Arguments

:: (MonadUnliftIO m, MonadLoggerIO m) |
=> SqliteConnectionInfo |
-> Int | number of connections to open
-> (Pool (RawSqlite SqlBackend) -> m a) |
-> m a |

Like `createSqlitePoolInfo`, but based on `createRawSqlitePoolFromInfo_`.

Since: 2.10.6