-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Type-safe, multi-backend data serialization. -- -- Type-safe, data serialization. You must use a specific backend in -- order to make this useful. @package persistent @version 2.0.5 module Database.Persist.Types -- | A Checkmark should be used as a field type whenever a -- uniqueness constraint should guarantee that a certain kind of record -- may appear at most once, but other kinds of records may appear any -- number of times. -- -- NOTE: You need to mark any Checkmark fields as -- nullable (see the following example). -- -- For example, suppose there's a Location entity that -- represents where a user has lived: -- -- 
--    Location
--        user    UserId
--        name    Text
--        current Checkmark nullable
--   
--   UniqueLocation user current
--
-- -- The UniqueLocation constraint allows any number of -- Inactive Locations to be current. However, -- there may be at most one current Location per user -- (i.e., either zero or one per user). -- -- This data type works because of the way that SQL treats -- NULLable fields within uniqueness constraints. The SQL -- standard says that NULL values should be considered -- different, so we represent Inactive as SQL NULL, thus -- allowing any number of Inactive records. On the other hand, we -- represent Active as TRUE, so the uniqueness constraint -- will disallow more than one Active record. -- -- Note: There may be DBMSs that do not respect the SQL standard's -- treatment of NULL values on uniqueness constraints, please -- check if this data type works before relying on it. -- -- The SQL BOOLEAN type is used because it's the smallest data -- type available. Note that we never use FALSE, just -- TRUE and NULL. Provides the same behavior Maybe -- () would if () was a valid PersistField. data Checkmark -- | When used on a uniqueness constraint, there may be at most one -- Active record. Active :: Checkmark -- | When used on a uniqueness constraint, there may be any number of -- Inactive records. Inactive :: Checkmark data IsNullable Nullable :: !WhyNullable -> IsNullable NotNullable :: IsNullable -- | The reason why a field is nullable is very important. A field -- that is nullable because of a Maybe tag will have its type -- changed from A to Maybe A. OTOH, a field that is -- nullable because of a nullable tag will remain with the same -- type. data WhyNullable ByMaybeAttr :: WhyNullable ByNullableAttr :: WhyNullable data EntityDef EntityDef :: !HaskellName -> !DBName -> !FieldDef -> ![Attr] -> ![FieldDef] -> ![UniqueDef] -> ![ForeignDef] -> ![Text] -> !(Map Text [ExtraLine]) -> !Bool -> EntityDef entityHaskell :: EntityDef -> !HaskellName entityDB :: EntityDef -> !DBName entityId :: EntityDef -> !FieldDef entityAttrs :: EntityDef -> ![Attr] entityFields :: EntityDef -> ![FieldDef] entityUniques :: EntityDef -> ![UniqueDef] entityForeigns :: EntityDef -> ![ForeignDef] entityDerives :: EntityDef -> ![Text] entityExtra :: EntityDef -> !(Map Text [ExtraLine]) entitySum :: EntityDef -> !Bool entityPrimary :: EntityDef -> Maybe CompositeDef type ExtraLine = [Text] newtype HaskellName HaskellName :: Text -> HaskellName unHaskellName :: HaskellName -> Text newtype DBName DBName :: Text -> DBName unDBName :: DBName -> Text type Attr = Text data FieldType -- | Optional module and name. FTTypeCon :: (Maybe Text) -> Text -> FieldType FTApp :: FieldType -> FieldType -> FieldType FTList :: FieldType -> FieldType data FieldDef FieldDef :: !HaskellName -> !DBName -> !FieldType -> !SqlType -> ![Attr] -> !Bool -> !ReferenceDef -> FieldDef -- | name of the field fieldHaskell :: FieldDef -> !HaskellName fieldDB :: FieldDef -> !DBName fieldType :: FieldDef -> !FieldType fieldSqlType :: FieldDef -> !SqlType -- | user annotations for a field fieldAttrs :: FieldDef -> ![Attr] -- | a strict field in the data type. Default: true fieldStrict :: FieldDef -> !Bool fieldReference :: FieldDef -> !ReferenceDef -- | There are 3 kinds of references 1) composite (to fields that exist in -- the record) 2) single field 3) embedded -- -- embedding isn't really a reference data ReferenceDef NoReference :: ReferenceDef -- | A ForeignRef has a late binding to the EntityDef it references via -- HaskellName and has the Haskell type of the foreign key in the form of -- FieldType ForeignRef :: !HaskellName -> !FieldType -> ReferenceDef EmbedRef :: EmbedEntityDef -> ReferenceDef CompositeRef :: CompositeDef -> ReferenceDef -- | An EmbedEntityDef is the same as an EntityDef But it is only used for -- fieldReference so it only has data needed for embedding data EmbedEntityDef EmbedEntityDef :: !HaskellName -> ![EmbedFieldDef] -> EmbedEntityDef embeddedHaskell :: EmbedEntityDef -> !HaskellName embeddedFields :: EmbedEntityDef -> ![EmbedFieldDef] -- | An EmbedFieldDef is the same as a FieldDef But it is only used for -- embeddedFields so it only has data needed for embedding data EmbedFieldDef EmbedFieldDef :: !DBName -> Maybe EmbedEntityDef -> EmbedFieldDef emFieldDB :: EmbedFieldDef -> !DBName emFieldEmbed :: EmbedFieldDef -> Maybe EmbedEntityDef toEmbedEntityDef :: EntityDef -> EmbedEntityDef toEmbedFieldDef :: FieldDef -> EmbedFieldDef data UniqueDef UniqueDef :: !HaskellName -> !DBName -> ![(HaskellName, DBName)] -> ![Attr] -> UniqueDef uniqueHaskell :: UniqueDef -> !HaskellName uniqueDBName :: UniqueDef -> !DBName uniqueFields :: UniqueDef -> ![(HaskellName, DBName)] uniqueAttrs :: UniqueDef -> ![Attr] data CompositeDef CompositeDef :: ![FieldDef] -> ![Attr] -> CompositeDef compositeFields :: CompositeDef -> ![FieldDef] compositeAttrs :: CompositeDef -> ![Attr] -- | Used instead of FieldDef to generate a smaller amount of code type ForeignFieldDef = (HaskellName, DBName) data ForeignDef ForeignDef :: !HaskellName -> !DBName -> !HaskellName -> !DBName -> ![(ForeignFieldDef, ForeignFieldDef)] -> ![Attr] -> Bool -> ForeignDef foreignRefTableHaskell :: ForeignDef -> !HaskellName foreignRefTableDBName :: ForeignDef -> !DBName foreignConstraintNameHaskell :: ForeignDef -> !HaskellName foreignConstraintNameDBName :: ForeignDef -> !DBName foreignFields :: ForeignDef -> ![(ForeignFieldDef, ForeignFieldDef)] foreignAttrs :: ForeignDef -> ![Attr] foreignNullable :: ForeignDef -> Bool data PersistException -- | Generic Exception PersistError :: Text -> PersistException PersistMarshalError :: Text -> PersistException PersistInvalidField :: Text -> PersistException PersistForeignConstraintUnmet :: Text -> PersistException PersistMongoDBError :: Text -> PersistException PersistMongoDBUnsupported :: Text -> PersistException -- | A raw value which can be stored in any backend and can be marshalled -- to and from a PersistField. data PersistValue PersistText :: Text -> PersistValue PersistByteString :: ByteString -> PersistValue PersistInt64 :: Int64 -> PersistValue PersistDouble :: Double -> PersistValue PersistRational :: Rational -> PersistValue PersistBool :: Bool -> PersistValue PersistDay :: Day -> PersistValue PersistTimeOfDay :: TimeOfDay -> PersistValue PersistUTCTime :: UTCTime -> PersistValue PersistNull :: PersistValue PersistList :: [PersistValue] -> PersistValue PersistMap :: [(Text, PersistValue)] -> PersistValue -- | Intended especially for MongoDB backend PersistObjectId :: ByteString -> PersistValue -- | Using PersistDbSpecific allows you to use types specific to a -- particular backend For example, below is a simple example of the -- PostGIS geography type: -- -- 
--    data Geo = Geo ByteString
--   
--   instance PersistField Geo where
--      toPersistValue (Geo t) = PersistDbSpecific t
--   
--   fromPersistValue (PersistDbSpecific t) = Right $ Geo $ Data.ByteString.concat [', t, ']
--      fromPersistValue _ = Left Geo values must be converted from PersistDbSpecific
--   
--   instance PersistFieldSql Geo where
--      sqlType _ = SqlOther GEOGRAPHY(POINT,4326)
--   
--   toPoint :: Double -> Double -> Geo
--    toPoint lat lon = Geo $ Data.ByteString.concat ['POINT(, ps $ lon,  , ps $ lat, )']
--      where ps = Data.Text.pack . show
--
-- -- If Foo has a geography field, we can then perform insertions like the -- following: -- -- 
--   insert $ Foo (toPoint 44 44)
--
PersistDbSpecific :: ByteString -> PersistValue fromPersistValueText :: PersistValue -> Either Text Text -- | A SQL data type. Naming attempts to reflect the underlying Haskell -- datatypes, eg SqlString instead of SqlVarchar. Different SQL databases -- may have different translations for these types. data SqlType SqlString :: SqlType SqlInt32 :: SqlType SqlInt64 :: SqlType SqlReal :: SqlType SqlNumeric :: Word32 -> Word32 -> SqlType SqlBool :: SqlType SqlDay :: SqlType SqlTime :: SqlType -- | Always uses UTC timezone SqlDayTime :: SqlType SqlBlob :: SqlType -- | a backend-specific name SqlOther :: Text -> SqlType data PersistFilter Eq :: PersistFilter Ne :: PersistFilter Gt :: PersistFilter Lt :: PersistFilter Ge :: PersistFilter Le :: PersistFilter In :: PersistFilter NotIn :: PersistFilter BackendSpecificFilter :: Text -> PersistFilter data UpdateException KeyNotFound :: String -> UpdateException UpsertError :: String -> UpdateException data OnlyUniqueException OnlyUniqueException :: String -> OnlyUniqueException data PersistUpdate Assign :: PersistUpdate Add :: PersistUpdate Subtract :: PersistUpdate Multiply :: PersistUpdate Divide :: PersistUpdate data SomePersistField SomePersistField :: a -> SomePersistField -- | updataing a database entity -- -- Persistent users use combinators to create these data Update record Update :: EntityField record typ -> typ -> PersistUpdate -> Update record updateField :: Update record -> EntityField record typ updateValue :: Update record -> typ updateUpdate :: Update record -> PersistUpdate BackendUpdate :: (BackendSpecificUpdate (PersistEntityBackend record) record) -> Update record -- | query options -- -- Persistent users use these directly data SelectOpt record Asc :: (EntityField record typ) -> SelectOpt record Desc :: (EntityField record typ) -> SelectOpt record OffsetBy :: Int -> SelectOpt record LimitTo :: Int -> SelectOpt record -- | Filters which are available for select, updateWhere -- and deleteWhere. Each filter constructor specifies the field -- being filtered on, the type of comparison applied (equals, not equals, -- etc) and the argument for the comparison. -- -- Persistent users use combinators to create these data Filter record Filter :: EntityField record typ -> Either typ [typ] -> PersistFilter -> Filter record filterField :: Filter record -> EntityField record typ filterValue :: Filter record -> Either typ [typ] filterFilter :: Filter record -> PersistFilter -- | convenient for internal use, not needed for the API FilterAnd :: [Filter record] -> Filter record FilterOr :: [Filter record] -> Filter record BackendFilter :: (BackendSpecificFilter (PersistEntityBackend record) record) -> Filter record -- | Datatype that represents an entity, with both its Key and its -- Haskell record representation. -- -- When using a SQL-based backend (such as SQLite or PostgreSQL), an -- Entity may take any number of columns depending on how many -- fields it has. In order to reconstruct your entity on the Haskell -- side, persistent needs all of your entity columns and in the -- right order. Note that you don't need to worry about this when using -- persistent's API since everything is handled correctly behind -- the scenes. -- -- However, if you want to issue a raw SQL command that returns an -- Entity, then you have to be careful with the column order. -- While you could use SELECT Entity.* WHERE ... and that would -- work most of the time, there are times when the order of the columns -- on your database is different from the order that persistent -- expects (for example, if you add a new field in the middle of you -- entity definition and then use the migration code -- -- persistent will expect the column to be in the middle, but -- your DBMS will put it as the last column). So, instead of using a -- query like the one above, you may use rawSql (from the -- Database.Persist.GenericSql module) with its /entity selection -- placeholder/ (a double question mark ??). Using -- rawSql the query above must be written as SELECT ?? WHERE -- ... Then rawSql will replace ?? with the list -- of all columns that we need from your entity in the right order. If -- your query returns two entities (i.e. (Entity backend a, Entity -- backend b)), then you must you use SELECT ??, ?? WHERE -- ..., and so on. data PersistEntity record => Entity record Entity :: Key record -> record -> Entity record entityKey :: Entity record -> Key record entityVal :: Entity record -> record module Database.Persist.Quasi -- | Parses a quasi-quoted syntax into a list of entity definitions. parse :: PersistSettings -> Text -> [EntityDef] data PersistSettings PersistSettings :: !(Text -> Text) -> !Bool -> !Text -> PersistSettings psToDBName :: PersistSettings -> !(Text -> Text) -- | Whether fields are by default strict. Default value: True. -- -- Since 1.2 psStrictFields :: PersistSettings -> !Bool -- | The name of the id column. Default value: id The name of the -- id column can also be changed on a per-model basis -- https://github.com/yesodweb/persistent/wiki/Persistent-entity-syntax -- -- Since 2.0 psIdName :: PersistSettings -> !Text upperCaseSettings :: PersistSettings lowerCaseSettings :: PersistSettings nullable :: [Text] -> IsNullable instance Show a => Show (ParseState a) instance Show Token instance Eq Token module Database.Persist.Class class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStore backend where data family BackendKey backend insert_ val = insert val >> return () insertMany = mapM insert insertMany_ x = insertMany x >> return () updateGet key ups = do { update key ups; get key >>= maybe (liftIO $ throwIO $ KeyNotFound $ show key) return } get :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> ReaderT backend m (Maybe val) insert :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => val -> ReaderT backend m (Key val) insert_ :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => val -> ReaderT backend m () insertMany :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => [val] -> ReaderT backend m [Key val] insertMany_ :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => [val] -> ReaderT backend m () insertKey :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT backend m () repsert :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT backend m () replace :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT backend m () delete :: (PersistStore backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> ReaderT backend m () update :: (PersistStore backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => Key val -> [Update val] -> ReaderT backend m () updateGet :: (PersistStore backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => Key val -> [Update val] -> ReaderT backend m val -- | Same as get, but for a non-null (not Maybe) foreign key Unsafe unless -- your database is enforcing that the foreign key is valid getJust :: (PersistStore backend, PersistEntity val, Show (Key val), backend ~ PersistEntityBackend val, MonadIO m) => Key val -> ReaderT backend m val -- | curry this to make a convenience function that loads an associated -- model -- -- 
--   foreign = belongsTo foerignId
--
belongsTo :: (PersistStore backend, PersistEntity ent1, PersistEntity ent2, backend ~ PersistEntityBackend ent2, MonadIO m) => (ent1 -> Maybe (Key ent2)) -> ent1 -> ReaderT backend m (Maybe ent2) -- | same as belongsTo, but uses getJust and therefore is -- similarly unsafe belongsToJust :: (PersistStore backend, PersistEntity ent1, PersistEntity ent2, backend ~ PersistEntityBackend ent2, MonadIO m) => (ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2 -- | Queries against unique keys (other than the id). -- -- Please read the general Persistent documentation to learn how to -- create Unique keys. SQL backends automatically create uniqueness -- constraints, but for MongoDB you must manually place a unique index on -- the field. -- -- Some functions in this module (insertUnique, insertBy, and -- replaceUnique) first query the unique indexes to check for conflicts. -- You could instead optimistically attempt to perform the operation -- (e.g. replace instead of replaceUnique). However, -- -- class PersistStore backend => PersistUnique backend where insertUnique datum = do { conflict <- checkUnique datum; case conflict of { Nothing -> Just `liftM` insert datum Just _ -> return Nothing } } upsert record updates = do { uniqueKey <- onlyUnique record; mExists <- getBy uniqueKey; k <- case mExists of { Just (Entity k _) -> do { when (null updates) (replace k record); return k } Nothing -> insert record }; Entity k `liftM` updateGet k updates } getBy :: (PersistUnique backend, MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Unique val -> ReaderT backend m (Maybe (Entity val)) deleteBy :: (PersistUnique backend, MonadIO m, PersistEntityBackend val ~ backend, PersistEntity val) => Unique val -> ReaderT backend m () insertUnique :: (PersistUnique backend, MonadIO m, PersistEntityBackend val ~ backend, PersistEntity val) => val -> ReaderT backend m (Maybe (Key val)) upsert :: (PersistUnique backend, MonadIO m, PersistEntityBackend val ~ backend, PersistEntity val) => val -> [Update val] -> ReaderT backend m (Entity val) -- | A modification of getBy, which takes the PersistEntity -- itself instead of a Unique value. Returns a value matching -- one of the unique keys. This function makes the most sense on -- entities with a single Unique constructor. getByValue :: (MonadIO m, PersistEntity value, PersistUnique backend, PersistEntityBackend value ~ backend) => value -> ReaderT backend m (Maybe (Entity value)) -- | Insert a value, checking for conflicts with any unique constraints. If -- a duplicate exists in the database, it is returned as Left. -- Otherwise, the new 'Key is returned as Right. insertBy :: (MonadIO m, PersistEntity val, PersistUnique backend, PersistEntityBackend val ~ backend) => val -> ReaderT backend m (Either (Entity val) (Key val)) -- | Attempt to replace the record of the given key with the given new -- record. First query the unique fields to make sure the replacement -- maintains uniqueness constraints. Return Nothing if the -- replacement was made. If uniqueness is violated, return a Just -- with the Unique violation -- -- Since 1.2.2.0 replaceUnique :: (MonadIO m, Eq record, Eq (Unique record), PersistEntityBackend record ~ backend, PersistEntity record, PersistUnique backend) => Key record -> record -> ReaderT backend m (Maybe (Unique record)) -- | Check whether there are any conflicts for unique keys with this entity -- and existing entities in the database. -- -- Returns Nothing if the entity would be unique, and could thus -- safely be inserted. on a conflict returns the conflicting key checkUnique :: (MonadIO m, PersistEntityBackend record ~ backend, PersistEntity record, PersistUnique backend) => record -> ReaderT backend m (Maybe (Unique record)) -- | Return the single unique key for a record onlyUnique :: (MonadIO m, PersistEntity val, PersistUnique backend, PersistEntityBackend val ~ backend) => val -> ReaderT backend m (Unique val) class PersistStore backend => PersistQuery backend where selectFirst filts opts = do { srcRes <- selectSourceRes filts ((LimitTo 1) : opts); liftIO $ with srcRes ($$ head) } updateWhere :: (PersistQuery backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => [Filter val] -> [Update val] -> ReaderT backend m () deleteWhere :: (PersistQuery backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => [Filter val] -> ReaderT backend m () selectSourceRes :: (PersistQuery backend, PersistEntity val, PersistEntityBackend val ~ backend, MonadIO m1, MonadIO m2) => [Filter val] -> [SelectOpt val] -> ReaderT backend m1 (Acquire (Source m2 (Entity val))) selectFirst :: (PersistQuery backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => [Filter val] -> [SelectOpt val] -> ReaderT backend m (Maybe (Entity val)) selectKeysRes :: (PersistQuery backend, MonadIO m1, MonadIO m2, PersistEntity val, backend ~ PersistEntityBackend val) => [Filter val] -> [SelectOpt val] -> ReaderT backend m1 (Acquire (Source m2 (Key val))) count :: (PersistQuery backend, MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => [Filter val] -> ReaderT backend m Int -- | Get all records matching the given criterion in the specified order. -- Returns also the identifiers. selectSource :: (PersistQuery backend, MonadResource m, PersistEntity val, PersistEntityBackend val ~ backend, MonadReader env m, HasPersistBackend env backend) => [Filter val] -> [SelectOpt val] -> Source m (Entity val) -- | Get the Keys of all records matching the given criterion. selectKeys :: (PersistQuery backend, MonadResource m, PersistEntity val, backend ~ PersistEntityBackend val, MonadReader env m, HasPersistBackend env backend) => [Filter val] -> [SelectOpt val] -> Source m (Key val) -- | Call selectSource but return the result as a list. selectList :: (MonadIO m, PersistEntity val, PersistQuery backend, PersistEntityBackend val ~ backend) => [Filter val] -> [SelectOpt val] -> ReaderT backend m [Entity val] -- | Call selectKeys but return the result as a list. selectKeysList :: (MonadIO m, PersistEntity val, PersistQuery backend, PersistEntityBackend val ~ backend) => [Filter val] -> [SelectOpt val] -> ReaderT backend m [Key val] class (PersistStore backend, PersistEntity record, backend ~ PersistEntityBackend record) => DeleteCascade record backend deleteCascade :: (DeleteCascade record backend, MonadIO m) => Key record -> ReaderT backend m () deleteCascadeWhere :: (MonadIO m, DeleteCascade record backend, PersistQuery backend) => [Filter record] -> ReaderT backend m () -- | 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. class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record where type family PersistEntityBackend record data family Key record data family EntityField record :: * -> * data family Unique record keyToValues :: PersistEntity record => Key record -> [PersistValue] keyFromValues :: PersistEntity record => [PersistValue] -> Either Text (Key record) persistIdField :: PersistEntity record => EntityField record (Key record) entityDef :: (PersistEntity record, Monad m) => m record -> EntityDef persistFieldDef :: PersistEntity record => EntityField record typ -> FieldDef toPersistFields :: PersistEntity record => record -> [SomePersistField] fromPersistValues :: PersistEntity record => [PersistValue] -> Either Text record persistUniqueKeys :: PersistEntity record => record -> [Unique record] persistUniqueToFieldNames :: PersistEntity record => Unique record -> [(HaskellName, DBName)] persistUniqueToValues :: PersistEntity record => Unique record -> [PersistValue] fieldLens :: PersistEntity record => EntityField record field -> (forall f. Functor f => (field -> f field) -> Entity record -> f (Entity record)) -- | A value which can be marshalled to and from a PersistValue. class PersistField a toPersistValue :: PersistField a => a -> PersistValue fromPersistValue :: PersistField a => PersistValue -> Either Text a -- | 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. class PersistConfig c where type family PersistConfigBackend c :: (* -> *) -> * -> * type family PersistConfigPool c applyEnv = return loadConfig :: PersistConfig c => Value -> Parser c applyEnv :: PersistConfig c => c -> IO c createPoolConfig :: PersistConfig c => c -> IO (PersistConfigPool c) runPool :: (PersistConfig c, MonadBaseControl IO m, MonadIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a class HasPersistBackend env backend | env -> backend persistBackend :: HasPersistBackend env backend => env -> backend liftPersist :: (MonadReader env m, HasPersistBackend env backend, MonadIO m) => ReaderT backend IO a -> m a -- | Predefined toJSON. The resulting JSON looks like {"key": -- 1, "value": {"name": ...}}. -- -- The typical usage is: -- -- 
--   instance ToJSON User where
--       toJSON = keyValueEntityToJSON
--
keyValueEntityToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value -- | Predefined parseJSON. The input JSON looks like {"key": -- 1, "value": {"name": ...}}. -- -- The typical usage is: -- -- 
--   instance FromJSON User where
--       parseJSON = keyValueEntityFromJSON
--
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record) -- | Predefined toJSON. The resulting JSON looks like {"id": -- 1, "name": ...}. -- -- The typical usage is: -- -- 
--   instance ToJSON User where
--       toJSON = entityIdToJSON
--
entityIdToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value -- | Predefined parseJSON. The input JSON looks like {"id": 1, -- "name": ...}. -- -- The typical usage is: -- -- 
--   instance FromJSON User where
--       parseJSON = entityIdFromJSON
--
entityIdFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record) module Database.Persist -- | assign a field a value (=.) :: PersistField typ => EntityField v typ -> typ -> Update v -- | assign a field by addition (+=) (+=.) :: PersistField typ => EntityField v typ -> typ -> Update v -- | assign a field by subtraction (-=) (-=.) :: PersistField typ => EntityField v typ -> typ -> Update v -- | assign a field by multiplication (*=) (*=.) :: PersistField typ => EntityField v typ -> typ -> Update v -- | assign a field by division (/=) (/=.) :: PersistField typ => EntityField v typ -> typ -> Update v (==.) :: PersistField typ => EntityField v typ -> typ -> Filter v (!=.) :: PersistField typ => EntityField v typ -> typ -> Filter v (<.) :: PersistField typ => EntityField v typ -> typ -> Filter v (>.) :: PersistField typ => EntityField v typ -> typ -> Filter v (<=.) :: PersistField typ => EntityField v typ -> typ -> Filter v (>=.) :: PersistField typ => EntityField v typ -> typ -> Filter v -- | In (<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v -- | NotIn (/<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v -- | the OR of two lists of filters (||.) :: [Filter v] -> [Filter v] -> [Filter v] listToJSON :: [PersistValue] -> Text mapToJSON :: [(Text, PersistValue)] -> Text toJsonText :: ToJSON j => j -> Text getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)] limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val]) module Database.Persist.Sql data InsertSqlResult ISRSingle :: Text -> InsertSqlResult ISRInsertGet :: Text -> Text -> InsertSqlResult ISRManyKeys :: Text -> [PersistValue] -> InsertSqlResult data Connection Connection :: (Text -> IO Statement) -> (EntityDef -> [PersistValue] -> InsertSqlResult) -> IORef (Map Text Statement) -> IO () -> ([EntityDef] -> (Text -> IO Statement) -> EntityDef -> IO (Either [Text] [(Bool, Text)])) -> ((Text -> IO Statement) -> IO ()) -> ((Text -> IO Statement) -> IO ()) -> ((Text -> IO Statement) -> IO ()) -> (DBName -> Text) -> Text -> Text -> ((Int, Int) -> Bool -> Text -> Text) -> LogFunc -> Connection connPrepare :: Connection -> Text -> IO Statement -- | table name, column names, id name, either 1 or 2 statements to run connInsertSql :: Connection -> EntityDef -> [PersistValue] -> InsertSqlResult connStmtMap :: Connection -> IORef (Map Text Statement) connClose :: Connection -> IO () connMigrateSql :: Connection -> [EntityDef] -> (Text -> IO Statement) -> EntityDef -> IO (Either [Text] [(Bool, Text)]) connBegin :: Connection -> (Text -> IO Statement) -> IO () connCommit :: Connection -> (Text -> IO Statement) -> IO () connRollback :: Connection -> (Text -> IO Statement) -> IO () connEscapeName :: Connection -> DBName -> Text connNoLimit :: Connection -> Text connRDBMS :: Connection -> Text connLimitOffset :: Connection -> (Int, Int) -> Bool -> Text -> Text connLogFunc :: Connection -> LogFunc type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO () data Statement Statement :: IO () -> IO () -> ([PersistValue] -> IO Int64) -> (forall m. MonadIO m => [PersistValue] -> Acquire (Source m [PersistValue])) -> Statement stmtFinalize :: Statement -> IO () stmtReset :: Statement -> IO () stmtExecute :: Statement -> [PersistValue] -> IO Int64 stmtQuery :: Statement -> forall m. MonadIO m => [PersistValue] -> Acquire (Source m [PersistValue]) data Column Column :: !DBName -> !Bool -> !SqlType -> !(Maybe Text) -> !(Maybe DBName) -> !(Maybe Integer) -> !(Maybe (DBName, DBName)) -> Column cName :: Column -> !DBName cNull :: Column -> !Bool cSqlType :: Column -> !SqlType cDefault :: Column -> !(Maybe Text) cDefaultConstraintName :: Column -> !(Maybe DBName) cMaxLen :: Column -> !(Maybe Integer) cReference :: Column -> !(Maybe (DBName, DBName)) data PersistentSqlException StatementAlreadyFinalized :: Text -> PersistentSqlException Couldn'tGetSQLConnection :: PersistentSqlException type SqlBackend = Connection type SqlPersistT = ReaderT Connection -- | Deprecated: Please use SqlPersistT instead type SqlPersist = SqlPersistT type SqlPersistM = SqlPersistT (NoLoggingT (ResourceT IO)) type Sql = Text type CautiousMigration = [(Bool, Sql)] type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT Connection IO)) () type ConnectionPool = Pool Connection -- | A single column (see rawSql). Any PersistField may -- be used here, including PersistValue (which does not do any -- processing). newtype Single a Single :: a -> Single a unSingle :: Single a -> a -- | Class for data types that may be retrived from a rawSql -- query. class RawSql a rawSqlCols :: RawSql a => (DBName -> Text) -> a -> (Int, [Text]) rawSqlColCountReason :: RawSql a => a -> String rawSqlProcessRow :: RawSql a => [PersistValue] -> Either Text a class PersistField a => PersistFieldSql a sqlType :: PersistFieldSql a => Proxy a -> SqlType -- | A class for all numeric SQL keys, for easy conversion to/from Int64 -- values. -- -- Since 2.0.2 class IsSqlKey a toSqlKey :: IsSqlKey a => Int64 -> a fromSqlKey :: IsSqlKey a => a -> Int64 -- | Get a connection from the pool, run the given action, and then return -- the connection to the pool. runSqlPool :: MonadBaseControl IO m => SqlPersistT m a -> Pool Connection -> m a -- | Like withResource, but times out the operation if resource -- allocation does not complete within the given timeout period. -- -- Since 2.0.0 withResourceTimeout :: MonadBaseControl IO m => Int -> Pool a -> (a -> m b) -> m (Maybe b) runSqlConn :: MonadBaseControl IO m => SqlPersistT m a -> Connection -> m a runSqlPersistM :: SqlPersistM a -> Connection -> IO a runSqlPersistMPool :: SqlPersistM a -> Pool Connection -> IO a withSqlPool :: (MonadIO m, MonadLogger m, MonadBaseControl IO m) => (LogFunc -> IO Connection) -> Int -> (Pool Connection -> m a) -> m a createSqlPool :: (MonadIO m, MonadLogger m, MonadBaseControl IO m) => (LogFunc -> IO Connection) -> Int -> m (Pool Connection) askLogFunc :: (MonadBaseControl IO m, MonadLogger m) => m LogFunc withSqlConn :: (MonadIO m, MonadBaseControl IO m, MonadLogger m) => (LogFunc -> IO Connection) -> (Connection -> m a) -> m a close' :: Connection -> IO () parseMigration :: MonadIO m => Migration -> ReaderT Connection m (Either [Text] CautiousMigration) parseMigration' :: MonadIO m => Migration -> ReaderT Connection m (CautiousMigration) printMigration :: MonadIO m => Migration -> ReaderT Connection m () getMigration :: (MonadBaseControl IO m, MonadIO m) => Migration -> ReaderT Connection m [Sql] runMigration :: MonadIO m => Migration -> ReaderT Connection m () -- | Same as runMigration, but returns a list of the SQL commands -- executed instead of printing them to stderr. runMigrationSilent :: (MonadBaseControl IO m, MonadIO m) => Migration -> ReaderT Connection m [Text] runMigrationUnsafe :: MonadIO m => Migration -> ReaderT Connection m () migrate :: [EntityDef] -> EntityDef -> Migration withRawQuery :: MonadIO m => Text -> [PersistValue] -> Sink [PersistValue] IO a -> ReaderT Connection m a rawQuery :: (MonadResource m, MonadReader env m, HasPersistBackend env Connection) => Text -> [PersistValue] -> Source m [PersistValue] rawQueryRes :: (MonadIO m1, MonadIO m2) => Text -> [PersistValue] -> ReaderT Connection m1 (Acquire (Source m2 [PersistValue])) rawExecute :: MonadIO m => Text -> [PersistValue] -> ReaderT Connection m () rawExecuteCount :: MonadIO m => Text -> [PersistValue] -> ReaderT Connection m Int64 -- | Execute a raw SQL statement and return its results as a list. -- -- If you're using Entitys (which is quite likely), then -- you must use entity selection placeholders (double question -- mark, ??). These ?? placeholders are then replaced -- for the names of the columns that we need for your entities. You'll -- receive an error if you don't use the placeholders. Please see the -- Entitys documentation for more details. -- -- You may put value placeholders (question marks, ?) in your -- SQL query. These placeholders are then replaced by the values you pass -- on the second parameter, already correctly escaped. You may want to -- use toPersistValue to help you constructing the placeholder -- values. -- -- Since you're giving a raw SQL statement, you don't get any guarantees -- regarding safety. If rawSql is not able to parse the results of -- your query back, then an exception is raised. However, most common -- problems are mitigated by using the entity selection placeholder -- ??, and you shouldn't see any error at all if you're not -- using Single. rawSql :: (RawSql a, MonadIO m) => Text -> [PersistValue] -> ReaderT Connection m [a] -- | Same as deleteWhere, but returns the number of rows affected. -- -- Since 1.1.5 deleteWhereCount :: (PersistEntity val, MonadIO m, PersistEntityBackend val ~ Connection) => [Filter val] -> ReaderT Connection m Int64 -- | Same as updateWhere, but returns the number of rows affected. -- -- Since 1.1.5 updateWhereCount :: (PersistEntity val, MonadIO m, Connection ~ PersistEntityBackend val) => [Filter val] -> [Update val] -> ReaderT Connection m Int64 -- | Commit the current transaction and begin a new one. -- -- Since 1.2.0 transactionSave :: MonadIO m => ReaderT Connection m () -- | Roll back the current transaction and begin a new one. -- -- Since 1.2.0 transactionUndo :: MonadIO m => ReaderT Connection m () getStmtConn :: Connection -> Text -> IO Statement -- | Create the list of columns for the given entity. mkColumns :: [EntityDef] -> EntityDef -> ([Column], [UniqueDef], [ForeignDef]) defaultAttribute :: [Attr] -> Maybe Text -- | Generates sql for limit and offset for postgres, sqlite and mysql. decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Bool -> Text -> Text