Hoogle Search

Within LTS Haskell 22.18 (ghc-9.6.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. module Database.Persist

    Welcome to persistent! This library intends to provide an easy, flexible, and convenient interface to various data storage backends. Backends include SQL databases, like mysql, postgresql, and sqlite, as well as NoSQL databases, like mongodb and redis. If you intend on using a SQL database, then check out Database.Persist.Sql.

  2. persist :: RedisCtx m f => ByteString -> m (f Bool)

    hedis Database.Redis

    No documentation available.

  3. persist :: RedisCtx m f => ByteString -> m (f Bool)

    hedis Database.Redis.Sentinel

    No documentation available.

  4. class PersistConfig c

    persistent Database.Persist.Class

    Represents a value containing all the configuration options for a specific backend. This abstraction makes it easier to write code that can easily swap backends.

  5. class PersistCore backend

    persistent Database.Persist.Class

    No documentation available.

  6. class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record

    persistent Database.Persist.Class

    Persistent serialized Haskell records to the database. A Database Entity (A row in SQL, a document in MongoDB, etc) corresponds to a Key plus a Haskell record. For every Haskell record type stored in the database there is a corresponding PersistEntity instance. An instance of PersistEntity contains meta-data for the record. PersistEntity also helps abstract over different record types. That way the same query interface can return a PersistEntity, with each query returning different types of Haskell records. Some advanced type system capabilities are used to make this process type-safe. Persistent users usually don't need to understand the class associated data and functions.

  7. class PersistField a

    persistent Database.Persist.Class

    This class teaches Persistent how to take a custom type and marshal it to and from a PersistValue, allowing it to be stored in a database.

    Examples

    Simple Newtype
    You can use newtype to add more type safety/readability to a basis type like ByteString. In these cases, just derive PersistField and PersistFieldSql: 
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype HashedPassword = HashedPassword ByteString
deriving (Eq, Show, PersistField, PersistFieldSql)
    Smart Constructor Newtype
    In this example, we create a PersistField instance for a newtype following the "Smart Constructor" pattern. 
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
import qualified Data.Text as T
import qualified Data.Char as C

-- | An American Social Security Number
newtype SSN = SSN ErrorMessage
deriving (Eq, Show, PersistFieldSql)

mkSSN :: ErrorMessage -> Either ErrorMessage SSN
mkSSN t = if (T.length t == 9) && (T.all C.isDigit t)
then Right $ SSN t
else Left $ "Invalid SSN: " <> t

instance PersistField SSN where
toPersistValue (SSN t) = PersistText t
fromPersistValue (PersistText t) = mkSSN t
-- Handle cases where the database does not give us PersistText
fromPersistValue x = Left $ "File.hs: When trying to deserialize an SSN: expected PersistText, received: " <> T.pack (show x)
    Tips:
    • This file contain dozens of PersistField instances you can look at for examples.
    • Typically custom PersistField instances will only accept a single PersistValue constructor in fromPersistValue.
    • Internal PersistField instances accept a wide variety of PersistValues to accomodate e.g. storing booleans as integers, booleans or strings.
    • If you're making a custom instance and using a SQL database, you'll also need PersistFieldSql to specify the type of the database column.

  8. type PersistQuery a = PersistQueryWrite a

    persistent Database.Persist.Class

    A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.

  9. class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend

    persistent Database.Persist.Class

    Backends supporting conditional read operations.

  10. class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend

    persistent Database.Persist.Class

    Backends supporting conditional write operations

Page 1 of many | Next