Safe Haskell	Safe-Inferred
Language	Haskell2010

Database.Persist.Sql.Shim

Description

Defines all the persistent functions lifted into MonadSqlQuery, and re-exports a version of the Database.Persist.Sql module replacing each function with the lifted version.

This file is autogenerated, to keep it in sync with Database.Persist.Monad.Shim.

Synopsis

runSqlCommand :: SqlPersistT IO () -> Migration
addMigrations :: CautiousMigration -> Migration
addMigration :: Bool -> Sql -> Migration
reportErrors :: [Text] -> Migration
reportError :: Text -> Migration
migrate :: [EntityDef] -> EntityDef -> Migration
type Sql = Text
type CautiousMigration = [(Bool, Sql)]
type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT SqlBackend IO)) ()
newtype PersistUnsafeMigrationException = PersistUnsafeMigrationException [(Bool, Sql)]
decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text
orderClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [SelectOpt val] -> Text
filterClauseWithVals :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> (Text, [PersistValue])
filterClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> Text
data FilterTablePrefix
- = PrefixTableName
- | PrefixExcluded
fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB
tableDBName :: PersistEntity record => record -> EntityNameDB
fromSqlKey :: ToBackendKey SqlBackend record => Key record -> Int64
toSqlKey :: ToBackendKey SqlBackend record => Int64 -> Key record
close' :: BackendCompatible SqlBackend backend => backend -> IO ()
withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a
createSqlPoolWithConfig :: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> m (Pool backend)
createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)
withSqlPoolWithConfig :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> (Pool backend -> m a) -> m a
withSqlPool :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> (Pool backend -> m a) -> m a
liftSqlPersistMPool :: forall backend m a. (MonadIO m, BackendCompatible SqlBackend backend) => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> m a
runSqlPersistMPool :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> IO a
runSqlPersistM :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> backend -> IO a
runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a
runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a
acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)
acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)
runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a
runSqlPoolWithHooks :: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> (backend -> m before) -> (backend -> m after) -> (backend -> SomeException -> m onException) -> m a
runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> m a
runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a
runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a
getStmtConn :: SqlBackend -> Text -> IO Statement
unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record
class RawSql a where
- rawSqlCols :: (Text -> Text) -> a -> (Int, [Text])
- rawSqlColCountReason :: a -> String
- rawSqlProcessRow :: [PersistValue] -> Either Text a
newtype EntityWithPrefix (prefix :: Symbol) record = EntityWithPrefix {
- unEntityWithPrefix :: Entity record
}
class PersistField a => PersistFieldSql a where
- sqlType :: Proxy a -> SqlType
limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val])
toJsonText :: ToJSON j => j -> Text
mapToJSON :: [(Text, PersistValue)] -> Text
listToJSON :: [PersistValue] -> Text
(||.) :: [Filter v] -> [Filter v] -> [Filter v]
(/<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
(<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
(>=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(>.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(<=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(<.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(!=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(==.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(/=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(*=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(-=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(+=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])
defaultAttribute :: [FieldAttr] -> Maybe Text
emptyBackendSpecificOverrides :: BackendSpecificOverrides
setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides
getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)
data BackendSpecificOverrides
defaultConnectionPoolConfig :: ConnectionPoolConfig
data Column = Column {
- cName :: !FieldNameDB
- cNull :: !Bool
- cSqlType :: !SqlType
- cDefault :: !(Maybe Text)
- cGenerated :: !(Maybe Text)
- cDefaultConstraintName :: !(Maybe ConstraintNameDB)
- cMaxLen :: !(Maybe Integer)
- cReference :: !(Maybe ColumnReference)
}
data ColumnReference = ColumnReference {
- crTableName :: !EntityNameDB
- crConstraintName :: !ConstraintNameDB
- crFieldCascade :: !FieldCascade
}
data PersistentSqlException
- = StatementAlreadyFinalized Text
- | Couldn'tGetSQLConnection
type SqlPersistT = ReaderT SqlBackend
type SqlPersistM = SqlPersistT (NoLoggingT (ResourceT IO))
type ConnectionPool = Pool SqlBackend
data ConnectionPoolConfig = ConnectionPoolConfig {
- connectionPoolConfigStripes :: Int
- connectionPoolConfigIdleTimeout :: NominalDiffTime
- connectionPoolConfigSize :: Int
}
newtype Single a = Single {
- unSingle :: a
}
readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a
readToWrite :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlWriteBackend m a
writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a
newtype SqlReadBackend = SqlReadBackend {
- unSqlReadBackend :: SqlBackend
}
newtype SqlWriteBackend = SqlWriteBackend {
- unSqlWriteBackend :: SqlBackend
}
type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)
type SqlBackendCanWrite backend = (SqlBackendCanRead backend, PersistQueryWrite backend, PersistStoreWrite backend, PersistUniqueWrite backend)
type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a
type SqlWriteT (m :: Type -> Type) a = forall backend. SqlBackendCanWrite backend => ReaderT backend m a
type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)
type PersistUnique a = PersistUniqueWrite a
type PersistQuery a = PersistQueryWrite a
type PersistStore a = PersistStoreWrite a
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef
class PersistStoreRead backend => PersistUniqueRead backend where
- existsBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where
- insertUnique_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())
class PersistEntity record => OnlyOneUniqueKey record where
- onlyUniqueP :: record -> Unique record
type NoUniqueKeysError ty = (('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " does not have any unique keys.") :$$: ('Text "The function you are trying to call requires a unique key " :<>: 'Text "to be defined on the entity.")
type MultipleUniqueKeysError ty = ((('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " has multiple unique keys.") :$$: ('Text "The function you are trying to call requires only a single " :<>: 'Text "unique key.")) :$$: (('Text "There is probably a variant of the function with 'By' " :<>: 'Text "appended that will allow you to select a unique key ") :<>: 'Text "for the operation.")
class PersistEntity record => AtLeastOneUniqueKey record where
- requireUniquesP :: record -> NonEmpty (Unique record)
data SqlBackend
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend m a
type family BaseBackend backend
class HasPersistBackend backend where
- type BaseBackend backend
- persistBackend :: backend -> BaseBackend backend
class HasPersistBackend backend => IsPersistBackend backend
class BackendCompatible sup sub where
- projectBackend :: sub -> sup
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where
- toBackendKey :: Key record -> BackendKey backend
- fromBackendKey :: BackendKey backend -> Key record
data family BackendKey backend
class PersistCore backend where
- data BackendKey backend
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
toPersistValueJSON :: ToJSON a => a -> PersistValue
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value
entityValues :: PersistEntity record => Entity record -> [PersistValue]
tabulateEntity :: PersistEntity record => (forall a. EntityField record a -> a) -> Entity record
data family Unique record
data family EntityField record :: Type -> Type
data family Key record
type family PersistEntityBackend record
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 PersistEntityBackend record
- data Key record
- data EntityField record :: Type -> Type
- data Unique record
- keyToValues :: Key record -> [PersistValue]
- keyFromValues :: [PersistValue] -> Either Text (Key record)
- persistIdField :: EntityField record (Key record)
- entityDef :: proxy record -> EntityDef
- persistFieldDef :: EntityField record typ -> FieldDef
- toPersistFields :: record -> [PersistValue]
- fromPersistValues :: [PersistValue] -> Either Text record
- tabulateEntityA :: Applicative f => (forall a. EntityField record a -> f a) -> f (Entity record)
- persistUniqueKeys :: record -> [Unique record]
- persistUniqueToFieldNames :: Unique record -> NonEmpty (FieldNameHS, FieldNameDB)
- persistUniqueToValues :: Unique record -> [PersistValue]
- fieldLens :: EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity record)
- keyFromRecordM :: Maybe (record -> Key record)
type family BackendSpecificUpdate backend record
data Update record
- = PersistField typ => Update {
  - updateField :: EntityField record typ
  - updateValue :: typ
  - updateUpdate :: PersistUpdate
  }
- | BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record)
data SelectOpt record
- = Asc (EntityField record typ)
- | Desc (EntityField record typ)
- | OffsetBy Int
- | LimitTo Int
type family BackendSpecificFilter backend record
data Filter record
- = PersistField typ => Filter {
  - filterField :: EntityField record typ
  - filterValue :: FilterValue typ
  - filterFilter :: PersistFilter
  }
- | FilterAnd [Filter record]
- | FilterOr [Filter record]
- | BackendFilter (BackendSpecificFilter (PersistEntityBackend record) record)
data FilterValue typ where
- FilterValue :: forall typ. typ -> FilterValue typ
- FilterValues :: forall typ. [typ] -> FilterValue typ
- UnsafeValue :: forall a typ. PersistField a => a -> FilterValue typ
data Entity record = Entity {
- entityKey :: Key record
- entityVal :: record
}
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ where
- symbolToField :: EntityField rec typ
class SafeToInsert a
getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)]
class PersistField a where
- toPersistValue :: a -> PersistValue
- fromPersistValue :: PersistValue -> Either Text a
newtype OverflowNatural = OverflowNatural {
- unOverflowNatural :: Natural
}
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef
getEntityKeyFields :: EntityDef -> NonEmpty FieldDef
setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef
setEntityId :: FieldDef -> EntityDef -> EntityDef
getEntityIdField :: EntityDef -> Maybe FieldDef
getEntityId :: EntityDef -> EntityIdDef
isEntitySum :: EntityDef -> Bool
getEntityFieldsDatabase :: EntityDef -> [FieldDef]
getEntityFields :: EntityDef -> [FieldDef]
getEntityForeignDefs :: EntityDef -> [ForeignDef]
getEntityComments :: EntityDef -> Maybe Text
setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityExtra :: EntityDef -> Map Text [[Text]]
getEntityDBName :: EntityDef -> EntityNameDB
getEntityHaskellName :: EntityDef -> EntityNameHS
getEntityUniques :: EntityDef -> [UniqueDef]
getEntityUniquesNoPrimaryKey :: EntityDef -> [UniqueDef]
isFieldMaybe :: FieldDef -> Bool
isFieldNullable :: FieldDef -> IsNullable
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef
type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()
data InsertSqlResult
- = ISRSingle Text
- | ISRInsertGet Text Text
- | ISRManyKeys Text [PersistValue]
data Statement = Statement {
- stmtFinalize :: IO ()
- stmtReset :: IO ()
- stmtExecute :: [PersistValue] -> IO Int64
- stmtQuery :: forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())
}
renderCascadeAction :: CascadeAction -> Text
renderFieldCascade :: FieldCascade -> Text
noCascade :: FieldCascade
isHaskellField :: FieldDef -> Bool
isFieldNotGenerated :: FieldDef -> Bool
parseFieldAttrs :: [Text] -> [FieldAttr]
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable
data Checkmark
- = Active
- | Inactive
data IsNullable
- = Nullable !WhyNullable
- | NotNullable
data WhyNullable
- = ByMaybeAttr
- | ByNullableAttr
data EntityDef
data EntityIdDef
- = EntityIdField !FieldDef
- | EntityIdNaturalKey !CompositeDef
type ExtraLine = [Text]
type Attr = Text
data FieldAttr
- = FieldAttrMaybe
- | FieldAttrNullable
- | FieldAttrMigrationOnly
- | FieldAttrSafeToRemove
- | FieldAttrNoreference
- | FieldAttrReference Text
- | FieldAttrConstraint Text
- | FieldAttrDefault Text
- | FieldAttrSqltype Text
- | FieldAttrMaxlen Integer
- | FieldAttrSql Text
- | FieldAttrOther Text
data FieldType
- = FTTypeCon (Maybe Text) Text
- | FTLit FieldTypeLit
- | FTTypePromoted Text
- | FTApp FieldType FieldType
- | FTList FieldType
data ReferenceDef
- = NoReference
- | ForeignRef !EntityNameHS
- | EmbedRef EntityNameHS
- | SelfReference
data EmbedEntityDef = EmbedEntityDef {
- embeddedHaskell :: EntityNameHS
- embeddedFields :: [EmbedFieldDef]
}
data EmbedFieldDef = EmbedFieldDef {
- emFieldDB :: FieldNameDB
- emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)
}
data UniqueDef = UniqueDef {
- uniqueHaskell :: !ConstraintNameHS
- uniqueDBName :: !ConstraintNameDB
- uniqueFields :: !(NonEmpty (FieldNameHS, FieldNameDB))
- uniqueAttrs :: ![Attr]
}
data CompositeDef = CompositeDef {
- compositeFields :: !(NonEmpty FieldDef)
- compositeAttrs :: ![Attr]
}
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data ForeignDef = ForeignDef {
- foreignRefTableHaskell :: !EntityNameHS
- foreignRefTableDBName :: !EntityNameDB
- foreignConstraintNameHaskell :: !ConstraintNameHS
- foreignConstraintNameDBName :: !ConstraintNameDB
- foreignFieldCascade :: !FieldCascade
- foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)]
- foreignAttrs :: ![Attr]
- foreignNullable :: Bool
- foreignToPrimary :: Bool
}
data FieldCascade = FieldCascade {
- fcOnUpdate :: !(Maybe CascadeAction)
- fcOnDelete :: !(Maybe CascadeAction)
}
data CascadeAction
- = Cascade
- | Restrict
- | SetNull
- | SetDefault
data PersistException
- = PersistError Text
- | PersistMarshalError Text
- | PersistInvalidField Text
- | PersistForeignConstraintUnmet Text
- | PersistMongoDBError Text
- | PersistMongoDBUnsupported Text
data SqlType
- = SqlString
- | SqlInt32
- | SqlInt64
- | SqlReal
- | SqlNumeric Word32 Word32
- | SqlBool
- | SqlDay
- | SqlTime
- | SqlDayTime
- | SqlBlob
- | SqlOther Text
data PersistFilter
- = Eq
- | Ne
- | Gt
- | Lt
- | Ge
- | Le
- | In
- | NotIn
- | BackendSpecificFilter Text
data UpdateException
- = KeyNotFound String
- | UpsertError String
data PersistUpdate
- = Assign
- | Add
- | Subtract
- | Multiply
- | Divide
- | BackendSpecificUpdate Text
data FieldDef = FieldDef {
- fieldHaskell :: !FieldNameHS
- fieldDB :: !FieldNameDB
- fieldType :: !FieldType
- fieldSqlType :: !SqlType
- fieldAttrs :: ![FieldAttr]
- fieldStrict :: !Bool
- fieldReference :: !ReferenceDef
- fieldCascade :: !FieldCascade
- fieldComments :: !(Maybe Text)
- fieldGenerated :: !(Maybe Text)
- fieldIsImplicitIdColumn :: !Bool
}
data IsolationLevel
- = ReadUncommitted
- | ReadCommitted
- | RepeatableRead
- | Serializable
fromPersistValueText :: PersistValue -> Either Text Text
data PersistValue where
- PersistText Text
- PersistByteString ByteString
- PersistInt64 Int64
- PersistDouble Double
- PersistRational Rational
- PersistBool Bool
- PersistDay Day
- PersistTimeOfDay TimeOfDay
- PersistUTCTime UTCTime
- PersistNull
- PersistList [PersistValue]
- PersistMap [(Text, PersistValue)]
- PersistObjectId ByteString
- PersistArray [PersistValue]
- PersistLiteral_ LiteralType ByteString
- pattern PersistDbSpecific :: ByteString -> PersistValue
- pattern PersistLiteralEscaped :: ByteString -> PersistValue
- pattern PersistLiteral :: ByteString -> PersistValue
data LiteralType
- = Escaped
- | Unescaped
- | DbSpecific
class DatabaseName a where
- escapeWith :: (Text -> str) -> a -> str
newtype FieldNameDB = FieldNameDB {
- unFieldNameDB :: Text
}
newtype FieldNameHS = FieldNameHS {
- unFieldNameHS :: Text
}
newtype EntityNameHS = EntityNameHS {
- unEntityNameHS :: Text
}
newtype EntityNameDB = EntityNameDB {
- unEntityNameDB :: Text
}
newtype ConstraintNameDB = ConstraintNameDB {
- unConstraintNameDB :: Text
}
newtype ConstraintNameHS = ConstraintNameHS {
- unConstraintNameHS :: Text
}
type family PersistConfigPool c
type family PersistConfigBackend c :: (Type -> Type) -> Type -> Type
class PersistConfig c where
- type PersistConfigBackend c :: (Type -> Type) -> Type -> Type
- type PersistConfigPool c
- loadConfig :: Value -> Parser c
- applyEnv :: c -> IO c
- createPoolConfig :: c -> IO (PersistConfigPool c)
- runPool :: MonadUnliftIO m => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
get :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe record)
getMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Key record] -> m (Map (Key record) record)
getJust :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m record
getJustEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Entity record)
getEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe (Entity record))
belongsTo :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2)
belongsToJust :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Key record2) -> record1 -> m record2
insert :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Key record)
insert_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m ()
insertMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m [Key record]
insertMany_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()
insertEntityMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Entity record] -> m ()
insertKey :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()
repsert :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()
repsertMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [(Key record, record)] -> m ()
replace :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()
delete :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m ()
update :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m ()
updateGet :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m record
insertEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Entity record)
insertRecord :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m record
getBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m (Maybe (Entity record))
getByValue :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))
checkUnique :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Unique record))
checkUniqueUpdateable :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Entity record -> m (Maybe (Unique record))
deleteBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m ()
insertUnique :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Key record))
upsert :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> [Update record] -> m (Entity record)
upsertBy :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => Unique record -> record -> [Update record] -> m (Entity record)
putMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()
insertBy :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Either (Entity record) (Key record))
insertUniqueEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))
replaceUnique :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record, Typeable record, MonadSqlQuery m) => Key record -> record -> m (Maybe (Unique record))
onlyUnique :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Unique record)
selectSourceRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Entity record) m2 ()))
selectFirst :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record))
selectKeysRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Key record) m2 ()))
count :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int
exists :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Bool
selectSource :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m ()
selectKeys :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()
selectList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Entity record]
selectKeysList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Key record]
updateWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m ()
deleteWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m ()
deleteWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int64
updateWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m Int64
parseMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m (Either [Text] CautiousMigration)
parseMigration' :: (HasCallStack, MonadSqlQuery m) => Migration -> m CautiousMigration
printMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m ()
showMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]
getMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Sql]
runMigration :: MonadSqlQuery m => Migration -> m ()
runMigrationQuiet :: MonadSqlQuery m => Migration -> m [Text]
runMigrationSilent :: MonadSqlQuery m => Migration -> m [Text]
runMigrationUnsafe :: MonadSqlQuery m => Migration -> m ()
runMigrationUnsafeQuiet :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]
getFieldName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => EntityField record typ -> m Text
getTableName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m Text
withRawQuery :: MonadSqlQuery m => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> m a
rawQueryRes :: (MonadIO m2, MonadSqlQuery m) => Text -> [PersistValue] -> m (Acquire (ConduitM () [PersistValue] m2 ()))
rawQuery :: (MonadResource m, MonadSqlQuery m) => Text -> [PersistValue] -> ConduitM () [PersistValue] m ()
rawExecute :: MonadSqlQuery m => Text -> [PersistValue] -> m ()
rawExecuteCount :: MonadSqlQuery m => Text -> [PersistValue] -> m Int64
rawSql :: (RawSql a, MonadSqlQuery m) => Text -> [PersistValue] -> m [a]
transactionSave :: MonadSqlQuery m => m ()
transactionSaveWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()
transactionUndo :: MonadSqlQuery m => m ()
transactionUndoWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()
unsafeLiftSql :: MonadSqlQuery m => Text -> (forall m2. MonadIO m2 => SqlPersistT m2 a) -> m a

Documentation

runSqlCommand :: SqlPersistT IO () -> Migration #

Run an action against the database during a migration. Can be useful for eg creating Postgres extensions:

runSqlCommand $ rawExecute "CREATE EXTENSION IF NOT EXISTS "uuid-ossp";" []

Since: persistent-2.13.0.0

addMigrations :: CautiousMigration -> Migration #

Add a CautiousMigration (aka a [(Bool, Text)]) to the migration plan.

Since: persistent-2.9.2

addMigration #

Arguments

:: Bool	Is the migration unsafe to run? (eg a destructive or non-idempotent update on the schema). If `True`, the migration is unsafe, and will need to be run manually later. If `False`, the migration is safe, and can be run any number of times.
-> Sql	A `Text` value representing the command to run on the database.
-> Migration

Add a migration to the migration plan.

Since: persistent-2.9.2

reportErrors :: [Text] -> Migration #

Report multiple errors in a Migration.

Since: persistent-2.9.2

reportError :: Text -> Migration #

Report a single error in a Migration.

Since: persistent-2.9.2

migrate :: [EntityDef] -> EntityDef -> Migration #

Given a list of old entity definitions and a new EntityDef in val, this creates a Migration to update the old list of definitions with the new one.

type Sql = Text #

type CautiousMigration = [(Bool, Sql)] #

A list of SQL operations, marked with a safety flag. If the Bool is True, then the operation is *unsafe* - it might be destructive, or otherwise not idempotent. If the Bool is False, then the operation is *safe*, and can be run repeatedly without issues.

type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT SqlBackend IO)) () #

A Migration is a four level monad stack consisting of:

WriterT [Text] representing a log of errors in the migrations.
WriterT CautiousMigration representing a list of migrations to run, along with whether or not they are safe.
ReaderT SqlBackend, aka the SqlPersistT transformer for database interop.
IO for arbitrary IO.

newtype PersistUnsafeMigrationException #

An exception indicating that Persistent refused to run some unsafe migrations. Contains a list of pairs where the Bool tracks whether the migration was unsafe (True means unsafe), and the Sql is the sql statement for the migration.

Since: persistent-2.11.1.0

Constructors

PersistUnsafeMigrationException [(Bool, Sql)]

Instances

Instances details

Exception PersistUnsafeMigrationException
Instance details Defined in Database.Persist.Sql.Migration Methods toException :: PersistUnsafeMigrationException -> SomeException # fromException :: SomeException -> Maybe PersistUnsafeMigrationException # displayException :: PersistUnsafeMigrationException -> String #
Show PersistUnsafeMigrationException	This `Show` instance renders an error message suitable for printing to the console. This is a little dodgy, but since GHC uses Show instances when displaying uncaught exceptions, we have little choice.
Instance details Defined in Database.Persist.Sql.Migration Methods showsPrec :: Int -> PersistUnsafeMigrationException -> ShowS # show :: PersistUnsafeMigrationException -> String # showList :: [PersistUnsafeMigrationException] -> ShowS #

decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text #

Generates sql for limit and offset for postgres, sqlite and mysql.

orderClause #

Arguments

:: PersistEntity val
=> Maybe FilterTablePrefix	include table name or EXCLUDED
-> SqlBackend
-> [SelectOpt val]
-> Text

Render a [SelectOpt record] made up *only* of Asc and Desc constructors into a Text value suitable for inclusion into a SQL query.

Since: persistent-2.13.2.0

filterClauseWithVals #

Arguments

:: PersistEntity val
=> Maybe FilterTablePrefix	include table name or EXCLUDED
-> SqlBackend
-> [Filter val]
-> (Text, [PersistValue])

Render a [Filter record] into a Text value suitable for inclusion into a SQL query, as well as the [PersistValue] to properly fill in the ? place holders.

Since: persistent-2.12.1.0

filterClause #

Arguments

:: PersistEntity val
=> Maybe FilterTablePrefix	include table name or EXCLUDED
-> SqlBackend
-> [Filter val]
-> Text

Render a [Filter record] into a Text value suitable for inclusion into a SQL query.

Since: persistent-2.12.1.0

data FilterTablePrefix #

Used when determining how to prefix a column name in a WHERE clause.

Since: persistent-2.12.1.0

Constructors

PrefixTableName

Prefix the column with the table name. This is useful if the column name might be ambiguous.

Since: persistent-2.12.1.0

PrefixExcluded

Prefix the column name with the EXCLUDED keyword. This is used with the Postgresql backend when doing ON CONFLICT DO UPDATE clauses - see the documentation on upsertWhere and upsertManyWhere.

Since: persistent-2.12.1.0

fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB #

useful for a backend to implement fieldName by adding escaping

tableDBName :: PersistEntity record => record -> EntityNameDB #

useful for a backend to implement tableName by adding escaping

fromSqlKey :: ToBackendKey SqlBackend record => Key record -> Int64 #

toSqlKey :: ToBackendKey SqlBackend record => Int64 -> Key record #

close' :: BackendCompatible SqlBackend backend => backend -> IO () #

withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a #

Create a connection and run sql queries within it. This function automatically closes the connection on it's completion.

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 Control.Monad.Logger
import Conduit
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
|]

openConnection :: LogFunc -> IO SqlBackend
openConnection logfn = do
 conn <- open "/home/sibi/test.db"
 wrapConnection conn logfn

main :: IO ()
main = do
  runNoLoggingT $ runResourceT $ withSqlConn openConnection (\backend ->
                                      flip runSqlConn backend $ do
                                        runMigration migrateAll
                                        insert_ $ Person "John doe" $ Just 35
                                        insert_ $ Person "Divya" $ Just 36
                                        (pers :: [Entity Person]) <- selectList [] []
                                        liftIO $ print pers
                                        return ()
                                     )

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}}]

createSqlPoolWithConfig #

Arguments

:: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)
=> (LogFunc -> IO backend)	Function to create a new connection
-> ConnectionPoolConfig
-> m (Pool backend)

Creates a pool of connections to a SQL database.

Since: persistent-2.11.0.0

createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend) #

withSqlPoolWithConfig #

Arguments

:: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)
=> (LogFunc -> IO backend)	Function to create a new connection
-> ConnectionPoolConfig
-> (Pool backend -> m a)
-> m a

Creates a pool of connections to a SQL database which can be used by the Pool backend -> m a function. After the function completes, the connections are destroyed.

Since: persistent-2.11.0.0

withSqlPool #

Arguments

:: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)
=> (LogFunc -> IO backend)	create a new connection
-> Int	connection count
-> (Pool backend -> m a)
-> m a

liftSqlPersistMPool :: forall backend m a. (MonadIO m, BackendCompatible SqlBackend backend) => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> m a #

runSqlPersistMPool :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> IO a #

runSqlPersistM :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> backend -> IO a #

runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a #

Like runSqlConn, but supports specifying an isolation level.

Since: persistent-2.9.0

runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a #

acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend) #

Like acquireSqlConn, but lets you specify an explicit isolation level.

Since: persistent-2.10.5

acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend) #

Starts a new transaction on the connection. When the acquired connection is released the transaction is committed and the connection returned to the pool.

Upon an exception the transaction is rolled back and the connection destroyed.

This is equivalent to runSqlConn but does not incur the MonadUnliftIO constraint, meaning it can be used within, for example, a Conduit pipeline.

Since: persistent-2.10.5

runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a #

This function is how runSqlPoolWithHooks is defined.

It's currently the most general function for using a SQL pool.

Since: persistent-2.13.0.0

runSqlPoolWithHooks #

Arguments

:: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend)
=> ReaderT backend m a
-> Pool backend
-> Maybe IsolationLevel
-> (backend -> m before)	Run this action immediately before the action is performed.
-> (backend -> m after)	Run this action immediately after the action is completed.
-> (backend -> SomeException -> m onException)	This action is performed when an exception is received. The exception is provided as a convenience - it is rethrown once this cleanup function is complete.
-> m a

This function is how runSqlPool and runSqlPoolNoTransaction are defined. In addition to the action to be performed and the Pool of conections to use, we give you the opportunity to provide three actions - initialize, afterwards, and onException.

Since: persistent-2.12.0.0

runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> m a #

Like runSqlPool, but does not surround the action in a transaction. This action might leave your database in a weird state.

Since: persistent-2.12.0.0

runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a #

Like runSqlPool, but supports specifying an isolation level.

Since: persistent-2.9.0

runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a #

Get a connection from the pool, run the given action, and then return the connection to the pool.

This function performs the given action in a transaction. If an exception occurs during the action, then the transaction is rolled back.

Note: This function previously timed out after 2 seconds, but this behavior was buggy and caused more problems than it solved. Since version 2.1.2, it performs no timeout checks.

getStmtConn :: SqlBackend -> Text -> IO Statement #

unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record #

A helper function to tell GHC what the EntityWithPrefix prefix should be. This allows you to use a type application to specify the prefix, instead of specifying the etype on the result.

As an example, here's code that uses this:

myQuery :: SqlPersistM [Entity Person]
myQuery = fmap (unPrefix @"p") $ rawSql query []
  where
    query = "SELECT ?? FROM person AS p"

Since: persistent-2.10.5

class RawSql a where #

Class for data types that may be retrived from a rawSql query.

Methods

rawSqlCols :: (Text -> Text) -> a -> (Int, [Text]) #

Number of columns that this data type needs and the list of substitutions for SELECT placeholders ??.

rawSqlColCountReason :: a -> String #

A string telling the user why the column count is what it is.

rawSqlProcessRow :: [PersistValue] -> Either Text a #

Transform a row of the result into the data type.

Instances

Instances details

(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Entity record -> (Int, [Text]) # rawSqlColCountReason :: Entity record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record) #
(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Key a -> (Int, [Text]) # rawSqlColCountReason :: Key a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Key a) #
PersistField a => RawSql (Single a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Single a -> (Int, [Text]) # rawSqlColCountReason :: Single a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Single a) #
RawSql a => RawSql (Maybe a)	Since: persistent-1.0.1
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Maybe a -> (Int, [Text]) # rawSqlColCountReason :: Maybe a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Maybe a) #
(PersistEntity record, KnownSymbol prefix, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (EntityWithPrefix prefix record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> EntityWithPrefix prefix record -> (Int, [Text]) # rawSqlColCountReason :: EntityWithPrefix prefix record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (EntityWithPrefix prefix record) #
(RawSql a, RawSql b) => RawSql (a, b)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b) -> (Int, [Text]) # rawSqlColCountReason :: (a, b) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b) #
(RawSql a, RawSql b, RawSql c) => RawSql (a, b, c)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c) #
(RawSql a, RawSql b, RawSql c, RawSql d) => RawSql (a, b, c, d)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e) => RawSql (a, b, c, d, e)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f) => RawSql (a, b, c, d, e, f)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g) => RawSql (a, b, c, d, e, f, g)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h) => RawSql (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i) => RawSql (a, b, c, d, e, f, g, h, i)	Since: persistent-2.10.2
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j) => RawSql (a, b, c, d, e, f, g, h, i, j)	Since: persistent-2.10.2
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k) => RawSql (a, b, c, d, e, f, g, h, i, j, k)	Since: persistent-2.10.2
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l)	Since: persistent-2.10.2
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3, RawSql i3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3) #
(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3, RawSql i3, RawSql j3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3)	Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3) -> (Int, [Text]) # rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3) -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3) #

newtype EntityWithPrefix (prefix :: Symbol) record #

This newtype wrapper is useful when selecting an entity out of the database and you want to provide a prefix to the table being selected.

Consider this raw SQL query:

SELECT ??
FROM my_long_table_name AS mltn
INNER JOIN other_table AS ot
   ON mltn.some_col = ot.other_col
WHERE ...

We don't want to refer to my_long_table_name every time, so we create an alias. If we want to select it, we have to tell the raw SQL quasi-quoter that we expect the entity to be prefixed with some other name.

We can give the above query a type with this, like:

getStuff :: SqlPersistM [EntityWithPrefix "mltn" MyLongTableName]
getStuff = rawSql queryText []

The EntityWithPrefix bit is a boilerplate newtype wrapper, so you can remove it with unPrefix, like this:

getStuff :: SqlPersistM [Entity MyLongTableName]
getStuff = unPrefix @"mltn" <$> rawSql queryText []

The symbol is a "type application" and requires the TypeApplications@ language extension.

Since: persistent-2.10.5

Constructors

EntityWithPrefix
Fields unEntityWithPrefix :: Entity record

Instances

Instances details

(PersistEntity record, KnownSymbol prefix, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (EntityWithPrefix prefix record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> EntityWithPrefix prefix record -> (Int, [Text]) # rawSqlColCountReason :: EntityWithPrefix prefix record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (EntityWithPrefix prefix record) #

class PersistField a => PersistFieldSql a where #

Tells Persistent what database column type should be used to store a Haskell type.

Examples

Expand

Simple Boolean Alternative

data Switch = On | Off
  deriving (Show, Eq)

instance PersistField Switch where
  toPersistValue s = case s of
    On -> PersistBool True
    Off -> PersistBool False
  fromPersistValue (PersistBool b) = if b then Right On else Right Off
  fromPersistValue x = Left $ "File.hs: When trying to deserialize a Switch: expected PersistBool, received: " <> T.pack (show x)

instance PersistFieldSql Switch where
  sqlType _ = SqlBool

Non-Standard Database Types

If your database supports non-standard types, such as Postgres' uuid, you can use SqlOther to use them:

import qualified Data.UUID as UUID
instance PersistField UUID where
  toPersistValue = PersistLiteralEncoded . toASCIIBytes
  fromPersistValue (PersistLiteralEncoded uuid) =
    case fromASCIIBytes uuid of
      Nothing -> Left $ "Model/CustomTypes.hs: Failed to deserialize a UUID; received: " <> T.pack (show uuid)
      Just uuid' -> Right uuid'
  fromPersistValue x = Left $ "File.hs: When trying to deserialize a UUID: expected PersistLiteralEncoded, received: "-- >  <> T.pack (show x)

instance PersistFieldSql UUID where
  sqlType _ = SqlOther "uuid"

User Created Database Types

Similarly, some databases support creating custom types, e.g. Postgres' DOMAIN and ENUM features. You can use SqlOther to specify a custom type:

CREATE DOMAIN ssn AS text
      CHECK ( value ~ '^[0-9]{9}$');

instance PersistFieldSQL SSN where
  sqlType _ = SqlOther "ssn"

CREATE TYPE rainbow_color AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet');

instance PersistFieldSQL RainbowColor where
  sqlType _ = SqlOther "rainbow_color"

Methods

sqlType :: Proxy a -> SqlType #

Instances

Instances details

PersistFieldSql Int16
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Int16 -> SqlType #
PersistFieldSql Int32
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Int32 -> SqlType #
PersistFieldSql Int64
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Int64 -> SqlType #
PersistFieldSql Int8
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Int8 -> SqlType #
PersistFieldSql Rational
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Rational -> SqlType #
PersistFieldSql Word16
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Word16 -> SqlType #
PersistFieldSql Word32
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Word32 -> SqlType #
PersistFieldSql Word64
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Word64 -> SqlType #
PersistFieldSql Word8
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Word8 -> SqlType #
PersistFieldSql Html
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Html -> SqlType #
PersistFieldSql ByteString
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy ByteString -> SqlType #
PersistFieldSql OverflowNatural	This type uses the `SqlInt64` version, which will exhibit overflow and underflow behavior. Additionally, it permits negative values in the database, which isn't ideal. Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy OverflowNatural -> SqlType #
PersistFieldSql PersistValue
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy PersistValue -> SqlType #
PersistFieldSql Checkmark
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Checkmark -> SqlType #
PersistFieldSql Text
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Text -> SqlType #
PersistFieldSql Text
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Text -> SqlType #
PersistFieldSql Day
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Day -> SqlType #
PersistFieldSql UTCTime
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy UTCTime -> SqlType #
PersistFieldSql TimeOfDay
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy TimeOfDay -> SqlType #
PersistFieldSql Bool
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Bool -> SqlType #
PersistFieldSql Double
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Double -> SqlType #
PersistFieldSql Int
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Int -> SqlType #
PersistFieldSql Word
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Word -> SqlType #
PersistFieldSql v => PersistFieldSql (IntMap v)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (IntMap v) -> SqlType #
(Ord a, PersistFieldSql a) => PersistFieldSql (Set a)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Set a) -> SqlType #
(PersistField record, PersistEntity record) => PersistFieldSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Entity record) -> SqlType #
PersistFieldSql a => PersistFieldSql (Vector a)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Vector a) -> SqlType #
PersistFieldSql a => PersistFieldSql (Maybe a)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Maybe a) -> SqlType #
PersistFieldSql [Char]
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy [Char] -> SqlType #
PersistFieldSql a => PersistFieldSql [a]
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy [a] -> SqlType #
HasResolution a => PersistFieldSql (Fixed a)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Fixed a) -> SqlType #
PersistFieldSql v => PersistFieldSql (Map Text v)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Map Text v) -> SqlType #
(PersistFieldSql a, PersistFieldSql b) => PersistFieldSql (a, b)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (a, b) -> SqlType #

limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val]) #

FIXME What's this exactly?

toJsonText :: ToJSON j => j -> Text #

A more general way to convert instances of ToJSON type class to strict text Text.

mapToJSON :: [(Text, PersistValue)] -> Text #

Convert map (list of tuples) into textual representation of JSON object. This is a type-constrained synonym for toJsonText.

listToJSON :: [PersistValue] -> Text #

Convert list of PersistValues into textual representation of JSON object. This is a type-constrained synonym for toJsonText.

(||.) :: [Filter v] -> [Filter v] -> [Filter v] infixl 3 #

The OR of two lists of filters. For example:

selectList
    ([ PersonAge >. 25
     , PersonAge <. 30 ] ||.
     [ PersonIncome >. 15000
     , PersonIncome <. 25000 ])
    []

will filter records where a person's age is between 25 and 30 or a person's income is between (15000 and 25000).

If you are looking for an (&&.) operator to do (A AND B AND (C OR D)) you can use the (++) operator instead as there is no (&&.). For example:

selectList
    ([ PersonAge >. 25
     , PersonAge <. 30 ] ++
    ([PersonCategory ==. 1] ||.
     [PersonCategory ==. 5]))
    []

will filter records where a person's age is between 25 and 30 and (person's category is either 1 or 5).

(/<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v infix 4 #

Check if value is not in given list.

Examples

selectSimon :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectSimon = selectList [UserAge /<-. [40]] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+

(<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v infix 4 #

Check if value is in given list.

Examples

selectUsers :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectUsers = selectList [UserAge <-. [40, 41]] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+

selectSPJ :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectSPJ = selectList [UserAge <-. [40]] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+

(>=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Greater-than or equal check.

Examples

selectGreaterEqualAge :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectGreaterEqualAge = selectList [UserAge >=. 41 ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+

(>.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Greater-than check.

Examples

selectGreaterAge :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectGreaterAge = selectList [UserAge >. 40 ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+

(<=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Less-than or equal check.

Examples

selectLessEqualAge :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectLessEqualAge = selectList [UserAge <=. 40 ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+

(<.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Less-than check.

Examples

selectLessAge :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectLessAge = selectList [UserAge <. 41 ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+

(!=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Non-equality check.

Examples

selectSimon :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectSimon = selectList [UserName !=. "SPJ" ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+

(==.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #

Check for equality.

Examples

selectSPJ :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectSPJ = selectList [UserName ==. "SPJ" ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+

(/=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #

Assign a field by division (/=).

Examples

divideAge :: MonadIO m => ReaderT SqlBackend m ()
divideAge = updateWhere [UserName ==. "SPJ" ] [UserAge /=. 2]

The above query when applied on dataset-1, will produce this:

+-----+-----+---------+
|id   |name |age      |
+-----+-----+---------+
|1    |SPJ  |40 -> 20 |
+-----+-----+---------+
|2    |Simon|41       |
+-----+-----+---------+

(*=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #

Assign a field by multiplication (*=).

Examples

multiplyAge :: MonadIO m => ReaderT SqlBackend m ()
multiplyAge = updateWhere [UserName ==. "SPJ" ] [UserAge *=. 2]

The above query when applied on dataset-1, will produce this:

+-----+-----+--------+
|id   |name |age     |
+-----+-----+--------+
|1    |SPJ  |40 -> 80|
+-----+-----+--------+
|2    |Simon|41      |
+-----+-----+--------+

(-=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #

Assign a field by subtraction (-=).

Examples

subtractAge :: MonadIO m => ReaderT SqlBackend m ()
subtractAge = updateWhere [UserName ==. "SPJ" ] [UserAge -=. 1]

The above query when applied on dataset-1, will produce this:

+-----+-----+---------+
|id   |name |age      |
+-----+-----+---------+
|1    |SPJ  |40 -> 39 |
+-----+-----+---------+
|2    |Simon|41       |
+-----+-----+---------+

(+=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #

Assign a field by addition (+=).

Examples

addAge :: MonadIO m => ReaderT SqlBackend m ()
addAge = updateWhere [UserName ==. "SPJ" ] [UserAge +=. 1]

The above query when applied on dataset-1, will produce this:

+-----+-----+---------+
|id   |name |age      |
+-----+-----+---------+
|1    |SPJ  |40 -> 41 |
+-----+-----+---------+
|2    |Simon|41       |
+-----+-----+---------+

(=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #

Assign a field a value.

Examples

updateAge :: MonadIO m => ReaderT SqlBackend m ()
updateAge = updateWhere [UserName ==. "SPJ" ] [UserAge =. 45]

Similar to updateWhere which is shown in the above example you can use other functions present in the module Database.Persist.Class. Note that the first parameter of updateWhere is [Filter val] and second parameter is [Update val]. By comparing this with the type of ==. and =., you can see that they match up in the above usage.

The above query when applied on dataset-1, will produce this:

+-----+-----+--------+
|id   |name |age     |
+-----+-----+--------+
|1    |SPJ  |40 -> 45|
+-----+-----+--------+
|2    |Simon|41      |
+-----+-----+--------+

mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef]) #

Create the list of columns for the given entity.

defaultAttribute :: [FieldAttr] -> Maybe Text #

emptyBackendSpecificOverrides :: BackendSpecificOverrides #

Creates an empty BackendSpecificOverrides (i.e. use the default behavior; no overrides)

Since: persistent-2.11

setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides #

Set the backend's foreign key generation function to this value.

Since: persistent-2.13.0.0

getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB) #

If the override is defined, then this returns a function that accepts an entity name and field name and provides the ConstraintNameDB for the foreign key constraint.

An abstract accessor for the BackendSpecificOverrides

Since: persistent-2.13.0.0

data BackendSpecificOverrides #

Record of functions to override the default behavior in mkColumns. It is recommended you initialize this with emptyBackendSpecificOverrides and override the default values, so that as new fields are added, your code still compiles.

For added safety, use the getBackendSpecific* and setBackendSpecific* functions, as a breaking change to the record field labels won't be reflected in a major version bump of the library.

Since: persistent-2.11

defaultConnectionPoolConfig :: ConnectionPoolConfig #

Initializes a ConnectionPoolConfig with default values. See the documentation of ConnectionPoolConfig for each field's default value.

Since: persistent-2.11.0.0

data Column #

Constructors

Column
Fields cName :: !FieldNameDB cNull :: !Bool cSqlType :: !SqlType cDefault :: !(Maybe Text) cGenerated :: !(Maybe Text) cDefaultConstraintName :: !(Maybe ConstraintNameDB) cMaxLen :: !(Maybe Integer) cReference :: !(Maybe ColumnReference)

Instances

Instances details

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

data ColumnReference #

This value specifies how a field references another table.

Since: persistent-2.11.0.0

Constructors

ColumnReference
Fields crTableName :: !EntityNameDB The table name that the Since: persistent-2.11.0.0 crConstraintName :: !ConstraintNameDB The name of the foreign key constraint. Since: persistent-2.11.0.0 crFieldCascade :: !FieldCascade Whether or not updates/deletions to the referenced table cascade to this table. Since: persistent-2.11.0.0

Instances

Instances details

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

data PersistentSqlException #

Constructors

StatementAlreadyFinalized Text
Couldn'tGetSQLConnection

Instances

Instances details

Exception PersistentSqlException
Instance details Defined in Database.Persist.Sql.Types Methods toException :: PersistentSqlException -> SomeException # fromException :: SomeException -> Maybe PersistentSqlException # displayException :: PersistentSqlException -> String #
Show PersistentSqlException
Instance details Defined in Database.Persist.Sql.Types Methods showsPrec :: Int -> PersistentSqlException -> ShowS # show :: PersistentSqlException -> String # showList :: [PersistentSqlException] -> ShowS #

type SqlPersistT = ReaderT SqlBackend #

type SqlPersistM = SqlPersistT (NoLoggingT (ResourceT IO)) #

type ConnectionPool = Pool SqlBackend #

data ConnectionPoolConfig #

Values to configure a pool of database connections. See Data.Pool for details.

Since: persistent-2.11.0.0

Constructors

ConnectionPoolConfig
Fields connectionPoolConfigStripes :: Int How many stripes to divide the pool into. See Data.Pool for details. Default: 1. connectionPoolConfigIdleTimeout :: NominalDiffTime How long connections can remain idle before being disposed of, in seconds. Default: 600 connectionPoolConfigSize :: Int How many connections should be held in the connection pool. Default: 10

Instances

Instances details

Show ConnectionPoolConfig
Instance details Defined in Database.Persist.Sql.Types Methods showsPrec :: Int -> ConnectionPoolConfig -> ShowS # show :: ConnectionPoolConfig -> String # showList :: [ConnectionPoolConfig] -> ShowS #

newtype Single a #

A single column (see rawSql). Any PersistField may be used here, including PersistValue (which does not do any processing).

Constructors

Single
Fields unSingle :: a

Instances

Instances details

Read a => Read (Single a)
Instance details Defined in Database.Persist.Sql.Types Methods readsPrec :: Int -> ReadS (Single a) # readList :: ReadS [Single a] # readPrec :: ReadPrec (Single a) # readListPrec :: ReadPrec [Single a] #
Show a => Show (Single a)
Instance details Defined in Database.Persist.Sql.Types Methods showsPrec :: Int -> Single a -> ShowS # show :: Single a -> String # showList :: [Single a] -> ShowS #
Eq a => Eq (Single a)
Instance details Defined in Database.Persist.Sql.Types Methods (==) :: Single a -> Single a -> Bool # (/=) :: Single a -> Single a -> Bool #
Ord a => Ord (Single a)
Instance details Defined in Database.Persist.Sql.Types Methods compare :: Single a -> Single a -> Ordering # (<) :: Single a -> Single a -> Bool # (<=) :: Single a -> Single a -> Bool # (>) :: Single a -> Single a -> Bool # (>=) :: Single a -> Single a -> Bool # max :: Single a -> Single a -> Single a # min :: Single a -> Single a -> Single a #
PersistField a => RawSql (Single a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Single a -> (Int, [Text]) # rawSqlColCountReason :: Single a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Single a) #

readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a #

Useful for running a read query against a backend with unknown capabilities.

readToWrite :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlWriteBackend m a #

Useful for running a read query against a backend with read and write capabilities.

writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a #

Useful for running a write query against an untagged backend with unknown capabilities.

newtype SqlReadBackend #

An SQL backend which can only handle read queries

The constructor was exposed in 2.10.0.

Constructors

SqlReadBackend
Fields unSqlReadBackend :: SqlBackend

Instances

Instances details

HasPersistBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlReadBackend # Methods persistBackend :: SqlReadBackend -> BaseBackend SqlReadBackend #
IsPersistBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend #
newtype BackendKey SqlReadBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlReadBackend = SqlReadBackendKey { unSqlReadBackendKey :: Int64 }
type BaseBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal type BaseBackend SqlReadBackend = SqlBackend
type Rep (BackendKey SqlReadBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlReadBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlReadBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlReadBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

newtype SqlWriteBackend #

An SQL backend which can handle read or write queries

The constructor was exposed in 2.10.0

Constructors

SqlWriteBackend
Fields unSqlWriteBackend :: SqlBackend

Instances

Instances details

HasPersistBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlWriteBackend # Methods persistBackend :: SqlWriteBackend -> BaseBackend SqlWriteBackend #
IsPersistBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend #
newtype BackendKey SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlWriteBackend = SqlWriteBackendKey { unSqlWriteBackendKey :: Int64 }
type BaseBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal type BaseBackend SqlWriteBackend = SqlBackend
type Rep (BackendKey SqlWriteBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlWriteBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlWriteBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlWriteBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend) #

A constraint synonym which witnesses that a backend is SQL and can run read queries.

type SqlBackendCanWrite backend = (SqlBackendCanRead backend, PersistQueryWrite backend, PersistStoreWrite backend, PersistUniqueWrite backend) #

A constraint synonym which witnesses that a backend is SQL and can run read and write queries.

type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a #

Like SqlPersistT but compatible with any SQL backend which can handle read queries.

type SqlWriteT (m :: Type -> Type) a = forall backend. SqlBackendCanWrite backend => ReaderT backend m a #

Like SqlPersistT but compatible with any SQL backend which can handle read and write queries.

type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend) #

A backend which is a wrapper around SqlBackend.

type PersistUnique a = PersistUniqueWrite a #

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.

type PersistQuery a = PersistQueryWrite a #

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.

type PersistStore a = PersistStoreWrite a #

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.

class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend #

Backends supporting conditional read operations.

Minimal complete definition

selectSourceRes, selectKeysRes, count, exists

class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend #

Backends supporting conditional write operations

Minimal complete definition

updateWhere, deleteWhere

onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef #

Given a proxy for a PersistEntity record, this returns the sole UniqueDef for that entity.

Since: persistent-2.13.0.0

class PersistStoreRead backend => PersistUniqueRead backend where #

Queries against Unique keys (other than the id Key).

Please read the general Persistent documentation to learn how to create Unique keys.

Using this with an Entity without a Unique key leads to undefined behavior. A few of these functions require a single Unique, so using an Entity with multiple Uniques is also undefined. In these cases persistent's goal is to throw an exception as soon as possible, but persistent is still transitioning to that.

SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on a field to have a uniqueness constraint.

Minimal complete definition

getBy

Methods

existsBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool #

Returns True if a record with this unique key exists, otherwise False.

Example usage

Expand

With schema-1 and dataset-1:

existsBySpjName :: MonadIO m  => ReaderT SqlBackend m Bool
existsBySpjName = existsBy $ UniqueUserName "SPJ"

spjEntExists <- existsBySpjName

The above query when applied on dataset-1, will return the value True.

Since: persistent-2.14.5

class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where #

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,

there is some fragility to trying to catch the correct exception and determing the column of failure;
an exception will automatically abort the current SQL transaction.

Minimal complete definition

deleteBy

Methods

insertUnique_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ()) #

Same as insertUnique but doesn't return a Key.

Example usage

Expand

With schema-1 and dataset-1, we try to insert the following two records:

linusId <- insertUnique_ $ User "Linus" 48
spjId   <- insertUnique_ $ User "SPJ" 90

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Linus |48   |
+-----+------+-----+

Linus's record was inserted to dataset-1, while SPJ wasn't because SPJ already exists in dataset-1.

Since: persistent-2.14.5.0

class PersistEntity record => OnlyOneUniqueKey record where #

This class is used to ensure that upsert is only called on records that have a single Unique key. The quasiquoter automatically generates working instances for appropriate records, and generates TypeError instances for records that have 0 or multiple unique keys.

Since: persistent-2.10.0

Methods

onlyUniqueP :: record -> Unique record #

type NoUniqueKeysError ty = (('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " does not have any unique keys.") :$$: ('Text "The function you are trying to call requires a unique key " :<>: 'Text "to be defined on the entity.") #

This is an error message. It is used when writing instances of OnlyOneUniqueKey for an entity that has no unique keys.

Since: persistent-2.10.0

type MultipleUniqueKeysError ty = ((('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " has multiple unique keys.") :$$: ('Text "The function you are trying to call requires only a single " :<>: 'Text "unique key.")) :$$: (('Text "There is probably a variant of the function with 'By' " :<>: 'Text "appended that will allow you to select a unique key ") :<>: 'Text "for the operation.") #

This is an error message. It is used when an entity has multiple unique keys, and the function expects a single unique key.

Since: persistent-2.10.0

class PersistEntity record => AtLeastOneUniqueKey record where #

This class is used to ensure that functions requring at least one unique key are not called with records that have 0 unique keys. The quasiquoter automatically writes working instances for appropriate entities, and generates TypeError instances for records that have 0 unique keys.

Since: persistent-2.10.0

Methods

requireUniquesP :: record -> NonEmpty (Unique record) #

data SqlBackend #

A SqlBackend represents a handle or connection to a database. It contains functions and values that allow databases to have more optimized implementations, as well as references that benefit performance and sharing.

Instead of using the SqlBackend constructor directly, use the mkSqlBackend function.

A SqlBackend is *not* thread-safe. You should not assume that a SqlBackend can be shared among threads and run concurrent queries. This *will* result in problems. Instead, you should create a Pool SqlBackend, known as a ConnectionPool, and pass that around in multi-threaded applications.

To run actions in the persistent library, you should use the runSqlConn function. If you're using a multithreaded application, use the runSqlPool function.

Instances

Instances details

HasPersistBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal Associated Types type BaseBackend SqlBackend # Methods persistBackend :: SqlBackend -> BaseBackend SqlBackend #
IsPersistBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal Methods mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend #
newtype BackendKey SqlBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlBackend = SqlBackendKey { unSqlBackendKey :: Int64 }
type BaseBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal type BaseBackend SqlBackend = SqlBackend
type Rep (BackendKey SqlBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b #

withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a #

Run a query against a compatible backend, by projecting the backend

This is a helper for using queries which run against a specific backend type that your backend is compatible with.

Since: persistent-2.12.0

withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend m a #

Run a query against a larger backend by plucking out BaseBackend backend

This is a helper for reusing existing queries when expanding the backend type.

Since: persistent-2.12.0

type family BaseBackend backend #

Instances

Instances details

type BaseBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal type BaseBackend SqlReadBackend = SqlBackend
type BaseBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal type BaseBackend SqlWriteBackend = SqlBackend
type BaseBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal type BaseBackend SqlBackend = SqlBackend

class HasPersistBackend backend where #

Class which allows the plucking of a BaseBackend backend from some larger type. For example, instance HasPersistBackend (SqlReadBackend, Int) where type BaseBackend (SqlReadBackend, Int) = SqlBackend persistBackend = unSqlReadBackend . fst

Associated Types

type BaseBackend backend #

Methods

persistBackend :: backend -> BaseBackend backend #

Instances

Instances details

HasPersistBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlReadBackend # Methods persistBackend :: SqlReadBackend -> BaseBackend SqlReadBackend #
HasPersistBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlWriteBackend # Methods persistBackend :: SqlWriteBackend -> BaseBackend SqlWriteBackend #
HasPersistBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal Associated Types type BaseBackend SqlBackend # Methods persistBackend :: SqlBackend -> BaseBackend SqlBackend #

class HasPersistBackend backend => IsPersistBackend backend #

Class which witnesses that backend is essentially the same as BaseBackend backend. That is, they're isomorphic and backend is just some wrapper over BaseBackend backend.

Minimal complete definition

mkPersistBackend

Instances

Instances details

IsPersistBackend SqlReadBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend #
IsPersistBackend SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend #
IsPersistBackend SqlBackend
Instance details Defined in Database.Persist.SqlBackend.Internal Methods mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend #

class BackendCompatible sup sub where #

This class witnesses that two backend are compatible, and that you can convert from the sub backend into the sup backend. This is similar to the HasPersistBackend and IsPersistBackend classes, but where you don't want to fix the type associated with the PersistEntityBackend of a record.

Generally speaking, where you might have:

foo ::
  ( PersistEntity record
  , PersistEntityBackend record ~ BaseBackend backend
  , IsSqlBackend backend
  )

this can be replaced with:

foo ::
  ( PersistEntity record,
  , PersistEntityBackend record ~ backend
  , BackendCompatible SqlBackend backend
  )

This works for SqlReadBackend because of the instance BackendCompatible SqlBackend SqlReadBackend, without needing to go through the BaseBackend type family.

Likewise, functions that are currently hardcoded to use SqlBackend can be generalized:

-- before:
asdf :: ReaderT SqlBackend m ()
asdf = pure ()

-- after:
asdf' :: BackendCompatible SqlBackend backend => ReaderT backend m ()
asdf' = withCompatibleBackend asdf

Since: persistent-2.7.1

Methods

projectBackend :: sub -> sup #

type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend) #

A convenient alias for common type signatures

class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where #

ToBackendKey converts a PersistEntity Key into a BackendKey This can be used by each backend to convert between a Key and a plain Haskell type. For Sql, that is done with toSqlKey and fromSqlKey.

By default, a PersistEntity uses the default BackendKey for its Key and is an instance of ToBackendKey

A Key that instead uses a custom type will not be an instance of ToBackendKey.

Methods

toBackendKey :: Key record -> BackendKey backend #

fromBackendKey :: BackendKey backend -> Key record #

data family BackendKey backend #

Instances

Instances details

newtype BackendKey SqlReadBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlReadBackend = SqlReadBackendKey { unSqlReadBackendKey :: Int64 }
newtype BackendKey SqlWriteBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlWriteBackend = SqlWriteBackendKey { unSqlWriteBackendKey :: Int64 }
newtype BackendKey SqlBackend
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore newtype BackendKey SqlBackend = SqlBackendKey { unSqlBackendKey :: Int64 }
type Rep (BackendKey SqlReadBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlReadBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlReadBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlReadBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))
type Rep (BackendKey SqlWriteBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlWriteBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlWriteBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlWriteBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))
type Rep (BackendKey SqlBackend)
Instance details Defined in Database.Persist.Sql.Orphan.PersistStore type Rep (BackendKey SqlBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'True) (C1 ('MetaCons "SqlBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

class PersistCore backend #

Associated Types

data BackendKey backend #

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend #

Minimal complete definition

get

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend #

Minimal complete definition

insert, insertKey, repsert, replace, delete, update

fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a #

Convenience function for getting a free PersistField instance from a type with JSON instances. The JSON parser used will accept JSON values other that object and arrays. So, if your instance serializes the data to a JSON string, this will still work.

Example usage in combination with toPersistValueJSON:

instance PersistField MyData where
  fromPersistValue = fromPersistValueJSON
  toPersistValue = toPersistValueJSON

toPersistValueJSON :: ToJSON a => a -> PersistValue #

Convenience function for getting a free PersistField instance from a type with JSON instances.

Example usage in combination with fromPersistValueJSON:

instance PersistField MyData where
  fromPersistValue = fromPersistValueJSON
  toPersistValue = toPersistValueJSON

entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record) #

Predefined parseJSON. The input JSON looks like {"id": 1, "name": ...}.

The typical usage is:

instance FromJSON (Entity User) where
    parseJSON = entityIdFromJSON

entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value #

Predefined toJSON. The resulting JSON looks like {"id": 1, "name": ...}.

The typical usage is:

instance ToJSON (Entity User) where
    toJSON = entityIdToJSON

keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record) #

Predefined parseJSON. The input JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

instance FromJSON (Entity User) where
    parseJSON = keyValueEntityFromJSON

keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value #

Predefined toJSON. The resulting JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

instance ToJSON (Entity User) where
    toJSON = keyValueEntityToJSON

entityValues :: PersistEntity record => Entity record -> [PersistValue] #

Get list of values corresponding to given entity.

tabulateEntity :: PersistEntity record => (forall a. EntityField record a -> a) -> Entity record #

Construct an Entity record by providing a value for each of the record's fields.

These constructions are equivalent:

entityMattConstructor, entityMattTabulate :: Entity User
entityMattConstructor =
    Entity
        { entityKey = toSqlKey 123
        , entityVal =
            User
                { userName = Matt
                , userAge = 33
                }
        }

entityMattTabulate =
    tabulateEntity $ \case
        UserId ->
            toSqlKey 123
        UserName ->
            Matt
        UserAge ->
            33

This is a specialization of tabulateEntityA, which allows you to construct an Entity by providing an Applicative action for each field instead of a regular function.

Since: persistent-2.14.0.0

data family Unique record #

Unique keys besides the Key.

data family EntityField record :: Type -> Type #

An EntityField is parameterised by the Haskell record it belongs to and the additional type of that field.

As of persistent-2.11.0.0, it's possible to use the OverloadedLabels language extension to refer to EntityField values polymorphically. See the documentation on SymbolToField for more information.

Instances

Instances details

SymbolToField sym rec typ => IsLabel sym (EntityField rec typ)

This instance delegates to SymbolToField to provide OverloadedLabels support to the EntityField type.

Since: persistent-2.11.0.0

Instance details

Defined in Database.Persist.Class.PersistEntity

Methods

fromLabel :: EntityField rec typ #

data family Key record #

By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.

Instances

Instances details

(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Key a -> (Int, [Text]) # rawSqlColCountReason :: Key a -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Key a) #

type family PersistEntityBackend record #

Persistent allows multiple different backends (databases).

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 #

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.

Minimal complete definition

keyToValues, keyFromValues, persistIdField, entityDef, persistFieldDef, toPersistFields, fromPersistValues, tabulateEntityA, persistUniqueKeys, persistUniqueToFieldNames, persistUniqueToValues, fieldLens

Associated Types

type PersistEntityBackend record #

Persistent allows multiple different backends (databases).

data Key record #

By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.

data EntityField record :: Type -> Type #

An EntityField is parameterised by the Haskell record it belongs to and the additional type of that field.

As of persistent-2.11.0.0, it's possible to use the OverloadedLabels language extension to refer to EntityField values polymorphically. See the documentation on SymbolToField for more information.

data Unique record #

Unique keys besides the Key.

Methods

keyToValues :: Key record -> [PersistValue] #

A lower-level key operation.

keyFromValues :: [PersistValue] -> Either Text (Key record) #

A lower-level key operation.

persistIdField :: EntityField record (Key record) #

A meta-operation to retrieve the Key EntityField.

entityDef :: proxy record -> EntityDef #

Retrieve the EntityDef meta-data for the record.

persistFieldDef :: EntityField record typ -> FieldDef #

Return meta-data for a given EntityField.

toPersistFields :: record -> [PersistValue] #

A meta-operation to get the database fields of a record.

fromPersistValues :: [PersistValue] -> Either Text record #

A lower-level operation to convert from database values to a Haskell record.

tabulateEntityA #

Arguments

:: Applicative f
=> (forall a. EntityField record a -> f a)	A function that builds a fragment of a record in an `Applicative` context.
-> f (Entity record)

This function allows you to build an Entity a by specifying an action that returns a value for the field in the callback function. Let's look at an example.

parseFromEnvironmentVariables :: IO (Entity User)
parseFromEnvironmentVariables =
    tabulateEntityA $ \userField ->
        case userField of
            UserName ->
                getEnv USER_NAME
            UserAge -> do
                ageVar <- getEnv USER_AGE
                case readMaybe ageVar of
                    Just age ->
                        pure age
                    Nothing ->
                        error $ "Failed to parse Age from: " <> ageVar
            UserAddressId -> do
                addressVar <- getEnv USER_ADDRESS_ID
                pure $ AddressKey addressVar

Since: persistent-2.14.0.0

persistUniqueKeys :: record -> [Unique record] #

A meta operation to retrieve all the Unique keys.

persistUniqueToFieldNames :: Unique record -> NonEmpty (FieldNameHS, FieldNameDB) #

A lower level operation.

persistUniqueToValues :: Unique record -> [PersistValue] #

A lower level operation.

fieldLens :: EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity record) #

Use a PersistField as a lens.

keyFromRecordM :: Maybe (record -> Key record) #

Extract a Key record from a record value. Currently, this is only defined for entities using the Primary syntax for natural/composite keys. In a future version of persistent which incorporates the ID directly into the entity, this will always be Just.

Since: persistent-2.11.0.0

type family BackendSpecificUpdate backend record #

data Update record #

Updating a database entity.

Persistent users use combinators to create these.

Constructors

PersistField typ => Update
Fields updateField :: EntityField record typ updateValue :: typ updateUpdate :: PersistUpdate
BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record)

data SelectOpt record #

Query options.

Persistent users use these directly.

Constructors

Asc (EntityField record typ)
Desc (EntityField record typ)
OffsetBy Int
LimitTo Int

type family BackendSpecificFilter backend record #

data Filter 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.

Note that it's important to be careful about the PersistFilter that you are using, if you use this directly. For example, using the In PersistFilter requires that you have an array- or list-shaped EntityField. It is possible to construct values using this that will create malformed runtime values.

Constructors

PersistField typ => Filter
Fields filterField :: EntityField record typ filterValue :: FilterValue typ filterFilter :: PersistFilter
FilterAnd [Filter record]	convenient for internal use, not needed for the API
FilterOr [Filter record]
BackendFilter (BackendSpecificFilter (PersistEntityBackend record) record)

data FilterValue typ where #

Value to filter with. Highly dependant on the type of filter used.

Since: persistent-2.10.0

Constructors

FilterValue :: forall typ. typ -> FilterValue typ
FilterValues :: forall typ. [typ] -> FilterValue typ
UnsafeValue :: forall a typ. PersistField a => a -> FilterValue typ

data Entity 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.Sql 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.

Constructors

Entity
Fields entityKey :: Key record entityVal :: record

Instances

Instances details

(Generic (Key record), Generic record) => Generic (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Associated Types type Rep (Entity record) :: Type -> Type # Methods from :: Entity record -> Rep (Entity record) x # to :: Rep (Entity record) x -> Entity record #
(Read (Key record), Read record) => Read (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods readsPrec :: Int -> ReadS (Entity record) # readList :: ReadS [Entity record] # readPrec :: ReadPrec (Entity record) # readListPrec :: ReadPrec [Entity record] #
(Show (Key record), Show record) => Show (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods showsPrec :: Int -> Entity record -> ShowS # show :: Entity record -> String # showList :: [Entity record] -> ShowS #
(Eq (Key record), Eq record) => Eq (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods (==) :: Entity record -> Entity record -> Bool # (/=) :: Entity record -> Entity record -> Bool #
(Ord (Key record), Ord record) => Ord (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods compare :: Entity record -> Entity record -> Ordering # (<) :: Entity record -> Entity record -> Bool # (<=) :: Entity record -> Entity record -> Bool # (>) :: Entity record -> Entity record -> Bool # (>=) :: Entity record -> Entity record -> Bool # max :: Entity record -> Entity record -> Entity record # min :: Entity record -> Entity record -> Entity record #
(TypeError (EntityErrorMessage a) :: Constraint) => SafeToInsert (Entity a)
Instance details Defined in Database.Persist.Class.PersistEntity
(PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods toPersistValue :: Entity record -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Entity record) #
(PersistField record, PersistEntity record) => PersistFieldSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy (Entity record) -> SqlType #
(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)
Instance details Defined in Database.Persist.Sql.Class Methods rawSqlCols :: (Text -> Text) -> Entity record -> (Int, [Text]) # rawSqlColCountReason :: Entity record -> String # rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record) #
type Rep (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity type Rep (Entity record) = D1 ('MetaData "Entity" "Database.Persist.Class.PersistEntity" "persistent-2.14.6.0-MwxHRJmapKL0rPNtlgHxp" 'False) (C1 ('MetaCons "Entity" 'PrefixI 'True) (S1 ('MetaSel ('Just "entityKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Key record)) :*: S1 ('MetaSel ('Just "entityVal") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 record)))

class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ where #

This type class is used with the OverloadedLabels extension to provide a more convenient means of using the EntityField type. EntityField definitions are prefixed with the type name to avoid ambiguity, but this ambiguity can result in verbose code.

If you have a table User with a name Text field, then the corresponding EntityField is UserName. With this, we can write #name :: EntityField User Text.

What's more fun is that the type is more general: it's actually #name :: (SymbolToField "name" rec typ) => EntityField rec typ

Which means it is *polymorphic* over the actual record. This allows you to write code that can be generic over the tables, provided they have the right fields.

Since: persistent-2.11.0.0

Methods

symbolToField :: EntityField rec typ #

class SafeToInsert a #

A type class which is used to witness that a type is safe to insert into the database without providing a primary key.

The TemplateHaskell function mkPersist will generate instances of this class for any entity that it works on. If the entity has a default primary key, then it provides a regular instance. If the entity has a Primary natural key, then this works fine. But if the entity has an Id column with no default=, then this does a TypeError and forces the user to use insertKey.

Since: persistent-2.14.0.0

Instances

Instances details

(TypeError (EntityErrorMessage a) :: Constraint) => SafeToInsert (Entity a)
Instance details Defined in Database.Persist.Class.PersistEntity
(TypeError (FunctionErrorMessage a b) :: Constraint) => SafeToInsert (a -> b)
Instance details Defined in Database.Persist.Class.PersistEntity

getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)] #

FIXME Add documentation to that.

class PersistField a where #

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

Expand

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.

Methods

toPersistValue :: a -> PersistValue #

fromPersistValue :: PersistValue -> Either Text a #

Instances

Instances details

PersistField Int16
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Int16 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int16 #
PersistField Int32
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Int32 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int32 #
PersistField Int64
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Int64 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int64 #
PersistField Int8
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Int8 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int8 #
PersistField Rational
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Rational -> PersistValue # fromPersistValue :: PersistValue -> Either Text Rational #
PersistField Word16
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Word16 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Word16 #
PersistField Word32
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Word32 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Word32 #
PersistField Word64
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Word64 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Word64 #
PersistField Word8
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Word8 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Word8 #
PersistField Html
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Html -> PersistValue # fromPersistValue :: PersistValue -> Either Text Html #
PersistField ByteString
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: ByteString -> PersistValue # fromPersistValue :: PersistValue -> Either Text ByteString #
PersistField OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: OverflowNatural -> PersistValue # fromPersistValue :: PersistValue -> Either Text OverflowNatural #
PersistField PersistValue
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: PersistValue -> PersistValue # fromPersistValue :: PersistValue -> Either Text PersistValue #
PersistField Checkmark
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Checkmark -> PersistValue # fromPersistValue :: PersistValue -> Either Text Checkmark #
PersistField Text
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Text -> PersistValue # fromPersistValue :: PersistValue -> Either Text Text #
PersistField Text
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Text -> PersistValue # fromPersistValue :: PersistValue -> Either Text0 Text #
PersistField Day
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Day -> PersistValue # fromPersistValue :: PersistValue -> Either Text Day #
PersistField UTCTime
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: UTCTime -> PersistValue # fromPersistValue :: PersistValue -> Either Text UTCTime #
PersistField TimeOfDay
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: TimeOfDay -> PersistValue # fromPersistValue :: PersistValue -> Either Text TimeOfDay #
(TypeError ((((('Text "The instance of PersistField for the Natural type was removed." :$$: 'Text "Please see the documentation for OverflowNatural if you want to ") :$$: 'Text "continue using the old behavior or want to see documentation on ") :$$: 'Text "why the instance was removed.") :$$: 'Text "") :$$: 'Text "This error instance will be removed in a future release.") :: Constraint) => PersistField Natural
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Natural -> PersistValue # fromPersistValue :: PersistValue -> Either Text Natural #
PersistField Bool
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Bool -> PersistValue # fromPersistValue :: PersistValue -> Either Text Bool #
PersistField Double
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Double -> PersistValue # fromPersistValue :: PersistValue -> Either Text Double #
PersistField Int
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Int -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int #
PersistField Word
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Word -> PersistValue # fromPersistValue :: PersistValue -> Either Text Word #
PersistField v => PersistField (IntMap v)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: IntMap v -> PersistValue # fromPersistValue :: PersistValue -> Either Text (IntMap v) #
(Ord a, PersistField a) => PersistField (Set a)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Set a -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Set a) #
(PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record)
Instance details Defined in Database.Persist.Class.PersistEntity Methods toPersistValue :: Entity record -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Entity record) #
PersistField a => PersistField (Vector a)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Vector a -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Vector a) #
PersistField a => PersistField (Maybe a)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Maybe a -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Maybe a) #
PersistField [Char]
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: [Char] -> PersistValue # fromPersistValue :: PersistValue -> Either Text [Char] #
PersistField a => PersistField [a]
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: [a] -> PersistValue # fromPersistValue :: PersistValue -> Either Text [a] #
HasResolution a => PersistField (Fixed a)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Fixed a -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Fixed a) #
PersistField v => PersistField (Map Text v)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Map Text v -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Map Text v) #
(PersistField a, PersistField b) => PersistField (a, b)
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: (a, b) -> PersistValue # fromPersistValue :: PersistValue -> Either Text (a, b) #

newtype OverflowNatural #

Prior to persistent-2.11.0, we provided an instance of PersistField for the Natural type. This was in error, because Natural represents an infinite value, and databases don't have reasonable types for this.

The instance for Natural used the Int64 underlying type, which will cause underflow and overflow errors. This type has the exact same code in the instances, and will work seamlessly.

A more appropriate type for this is the Word series of types from Data.Word. These have a bounded size, are guaranteed to be non-negative, and are quite efficient for the database to store.

Since: persistent-2.11.0

Constructors

OverflowNatural
Fields unOverflowNatural :: Natural

Instances

Instances details

Num OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods (+) :: OverflowNatural -> OverflowNatural -> OverflowNatural # (-) :: OverflowNatural -> OverflowNatural -> OverflowNatural # (*) :: OverflowNatural -> OverflowNatural -> OverflowNatural # negate :: OverflowNatural -> OverflowNatural # abs :: OverflowNatural -> OverflowNatural # signum :: OverflowNatural -> OverflowNatural # fromInteger :: Integer -> OverflowNatural #
Show OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods showsPrec :: Int -> OverflowNatural -> ShowS # show :: OverflowNatural -> String # showList :: [OverflowNatural] -> ShowS #
Eq OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods (==) :: OverflowNatural -> OverflowNatural -> Bool # (/=) :: OverflowNatural -> OverflowNatural -> Bool #
Ord OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods compare :: OverflowNatural -> OverflowNatural -> Ordering # (<) :: OverflowNatural -> OverflowNatural -> Bool # (<=) :: OverflowNatural -> OverflowNatural -> Bool # (>) :: OverflowNatural -> OverflowNatural -> Bool # (>=) :: OverflowNatural -> OverflowNatural -> Bool # max :: OverflowNatural -> OverflowNatural -> OverflowNatural # min :: OverflowNatural -> OverflowNatural -> OverflowNatural #
PersistField OverflowNatural
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: OverflowNatural -> PersistValue # fromPersistValue :: PersistValue -> Either Text OverflowNatural #
PersistFieldSql OverflowNatural	This type uses the `SqlInt64` version, which will exhibit overflow and underflow behavior. Additionally, it permits negative values in the database, which isn't ideal. Since: persistent-2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy OverflowNatural -> SqlType #

overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef #

Perform a mapping function over all of the entity fields, as determined by getEntityFieldsDatabase.

Since: persistent-2.13.0.0

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef #

Since: persistent-2.13.0.0

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef #

Since: persistent-2.13.0.0

setEntityId :: FieldDef -> EntityDef -> EntityDef #

Set an entityId to be the given FieldDef.

Since: persistent-2.13.0.0

getEntityIdField :: EntityDef -> Maybe FieldDef #

Since: persistent-2.13.0.0

getEntityId :: EntityDef -> EntityIdDef #

Since: persistent-2.13.0.0

isEntitySum :: EntityDef -> Bool #

Since: persistent-2.13.0.0

getEntityFieldsDatabase :: EntityDef -> [FieldDef] #

This returns all of the FieldDef defined for the EntityDef, including those fields that are marked as MigrationOnly (and therefore only present in the database) or SafeToRemove (and a migration will drop the column if it exists in the database).

For all the fields that are present on the Haskell-type, see getEntityFields.

Since: persistent-2.13.0.0

getEntityFields :: EntityDef -> [FieldDef] #

Retrieve the list of FieldDef that makes up the fields of the entity.

This does not return the fields for an Id column or an implicit id. It will return the key columns if you used the Primary syntax for defining the primary key.

This does not return fields that are marked SafeToRemove or MigrationOnly - so it only returns fields that are represented in the Haskell type. If you need those fields, use getEntityFieldsDatabase.

Since: persistent-2.13.0.0

getEntityForeignDefs :: EntityDef -> [ForeignDef] #

Since: persistent-2.13.0.0

getEntityComments :: EntityDef -> Maybe Text #

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef #

Since: persistent-2.13.0.0

getEntityExtra :: EntityDef -> Map Text [[Text]] #

getEntityDBName :: EntityDef -> EntityNameDB #

Return the database name for the given entity.

Since: persistent-2.13.0.0

getEntityHaskellName :: EntityDef -> EntityNameHS #

Retrieve the Haskell name of the given entity.

Since: persistent-2.13.0.0

getEntityUniques :: EntityDef -> [UniqueDef] #

Retrieve the list of UniqueDef from an EntityDef. As of version 2.14, this will also include the primary key on the entity, if one is defined. If you do not want the primary key, see getEntityUniquesNoPrimaryKey.

Since: persistent-2.13.0.0

getEntityUniquesNoPrimaryKey :: EntityDef -> [UniqueDef] #

Retrieve the list of UniqueDef from an EntityDef. This does not include a Primary key, if one is defined. A future version of persistent will include a Primary key among the Unique constructors for the Entity.

Since: persistent-2.14.0.0

isFieldMaybe :: FieldDef -> Bool #

Check if the field is `Maybe a`

Since: persistent-2.13.0.0

isFieldNullable :: FieldDef -> IsNullable #

Check if the field definition is nullable

Since: persistent-2.13.0.0

addFieldAttr :: FieldAttr -> FieldDef -> FieldDef #

Add an attribute to the list of field attributes.

Since: persistent-2.13.0.0

overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef #

Modify the list of field attributes.

Since: persistent-2.13.0.0

setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef #

Replace the FieldDef FieldAttr with the new list.

Since: persistent-2.13.0.0

type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO () #

data InsertSqlResult #

Constructors

ISRSingle Text
ISRInsertGet Text Text
ISRManyKeys Text [PersistValue]

data Statement #

A Statement is a representation of a database query that has been prepared and stored on the server side.

Constructors

Statement
Fields stmtFinalize :: IO () stmtReset :: IO () stmtExecute :: [PersistValue] -> IO Int64 stmtQuery :: forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())

renderCascadeAction :: CascadeAction -> Text #

Render a CascadeAction to Text such that it can be used in a SQL command.

Since: persistent-2.11.0

renderFieldCascade :: FieldCascade -> Text #

Renders a FieldCascade value such that it can be used in SQL migrations.

Since: persistent-2.11.0

noCascade :: FieldCascade #

A FieldCascade that does nothing.

Since: persistent-2.11.0

isHaskellField :: FieldDef -> Bool #

Returns True if the FieldDef does not have a MigrationOnly or SafeToRemove flag from the QuasiQuoter.

Since: persistent-2.13.0.0

isFieldNotGenerated :: FieldDef -> Bool #

parseFieldAttrs :: [Text] -> [FieldAttr] #

Parse raw field attributes into structured form. Any unrecognized attributes will be preserved, identically as they are encountered, as FieldAttrOther values.

Since: persistent-2.11.0.0

keyAndEntityFields :: EntityDef -> NonEmpty FieldDef #

Returns a NonEmpty list of FieldDef that correspond with the key columns for an EntityDef.

entityPrimary :: EntityDef -> Maybe CompositeDef #

entitiesPrimary :: EntityDef -> NonEmpty FieldDef #

Return the [FieldDef] for the entity keys.

fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable #

data Checkmark #

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.

Constructors

Active	When used on a uniqueness constraint, there may be at most one `Active` record.
Inactive	When used on a uniqueness constraint, there may be any number of `Inactive` records.

Instances

Instances details

Bounded Checkmark
Instance details Defined in Database.Persist.Types.Base Methods minBound :: Checkmark # maxBound :: Checkmark #
Enum Checkmark
Instance details Defined in Database.Persist.Types.Base Methods succ :: Checkmark -> Checkmark # pred :: Checkmark -> Checkmark # toEnum :: Int -> Checkmark # fromEnum :: Checkmark -> Int # enumFrom :: Checkmark -> [Checkmark] # enumFromThen :: Checkmark -> Checkmark -> [Checkmark] # enumFromTo :: Checkmark -> Checkmark -> [Checkmark] # enumFromThenTo :: Checkmark -> Checkmark -> Checkmark -> [Checkmark] #
Read Checkmark
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS Checkmark # readList :: ReadS [Checkmark] # readPrec :: ReadPrec Checkmark # readListPrec :: ReadPrec [Checkmark] #
Show Checkmark
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> Checkmark -> ShowS # show :: Checkmark -> String # showList :: [Checkmark] -> ShowS #
Eq Checkmark
Instance details Defined in Database.Persist.Types.Base Methods (==) :: Checkmark -> Checkmark -> Bool # (/=) :: Checkmark -> Checkmark -> Bool #
Ord Checkmark
Instance details Defined in Database.Persist.Types.Base Methods compare :: Checkmark -> Checkmark -> Ordering # (<) :: Checkmark -> Checkmark -> Bool # (<=) :: Checkmark -> Checkmark -> Bool # (>) :: Checkmark -> Checkmark -> Bool # (>=) :: Checkmark -> Checkmark -> Bool # max :: Checkmark -> Checkmark -> Checkmark # min :: Checkmark -> Checkmark -> Checkmark #
FromHttpApiData Checkmark
Instance details Defined in Database.Persist.Types.Base Methods parseUrlPiece :: Text -> Either Text Checkmark # parseHeader :: ByteString -> Either Text Checkmark # parseQueryParam :: Text -> Either Text Checkmark #
ToHttpApiData Checkmark
Instance details Defined in Database.Persist.Types.Base Methods toUrlPiece :: Checkmark -> Text # toEncodedUrlPiece :: Checkmark -> Builder # toHeader :: Checkmark -> ByteString # toQueryParam :: Checkmark -> Text # toEncodedQueryParam :: Checkmark -> Builder #
PathPiece Checkmark
Instance details Defined in Database.Persist.Types.Base Methods fromPathPiece :: Text -> Maybe Checkmark # toPathPiece :: Checkmark -> Text #
PersistField Checkmark
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Checkmark -> PersistValue # fromPersistValue :: PersistValue -> Either Text Checkmark #
PersistFieldSql Checkmark
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy Checkmark -> SqlType #

data IsNullable #

Constructors

Nullable !WhyNullable
NotNullable

Instances

Instances details

Show IsNullable
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> IsNullable -> ShowS # show :: IsNullable -> String # showList :: [IsNullable] -> ShowS #
Eq IsNullable
Instance details Defined in Database.Persist.Types.Base Methods (==) :: IsNullable -> IsNullable -> Bool # (/=) :: IsNullable -> IsNullable -> Bool #

data WhyNullable #

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.

Constructors

ByMaybeAttr
ByNullableAttr

Instances

Instances details

Show WhyNullable
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> WhyNullable -> ShowS # show :: WhyNullable -> String # showList :: [WhyNullable] -> ShowS #
Eq WhyNullable
Instance details Defined in Database.Persist.Types.Base Methods (==) :: WhyNullable -> WhyNullable -> Bool # (/=) :: WhyNullable -> WhyNullable -> Bool #

data EntityDef #

An EntityDef represents the information that persistent knows about an Entity. It uses this information to generate the Haskell datatype, the SQL migrations, and other relevant conversions.

Instances

Instances details

Read EntityDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EntityDef # readList :: ReadS [EntityDef] # readPrec :: ReadPrec EntityDef # readListPrec :: ReadPrec [EntityDef] #
Show EntityDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EntityDef -> ShowS # show :: EntityDef -> String # showList :: [EntityDef] -> ShowS #
Eq EntityDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: EntityDef -> EntityDef -> Bool # (/=) :: EntityDef -> EntityDef -> Bool #
Ord EntityDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: EntityDef -> EntityDef -> Ordering # (<) :: EntityDef -> EntityDef -> Bool # (<=) :: EntityDef -> EntityDef -> Bool # (>) :: EntityDef -> EntityDef -> Bool # (>=) :: EntityDef -> EntityDef -> Bool # max :: EntityDef -> EntityDef -> EntityDef # min :: EntityDef -> EntityDef -> EntityDef #
Lift EntityDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => EntityDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EntityDef -> Code m EntityDef #

data EntityIdDef #

The definition for the entity's primary key ID.

Since: persistent-2.13.0.0

Constructors

EntityIdField !FieldDef

The entity has a single key column, and it is a surrogate key - that is, you can't go from rec -> Key rec.

Since: persistent-2.13.0.0

EntityIdNaturalKey !CompositeDef

The entity has a natural key. This means you can write rec -> Key rec because all the key fields are present on the datatype.

A natural key can have one or more columns.

Since: persistent-2.13.0.0

Instances

Instances details

Read EntityIdDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EntityIdDef # readList :: ReadS [EntityIdDef] # readPrec :: ReadPrec EntityIdDef # readListPrec :: ReadPrec [EntityIdDef] #
Show EntityIdDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EntityIdDef -> ShowS # show :: EntityIdDef -> String # showList :: [EntityIdDef] -> ShowS #
Eq EntityIdDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: EntityIdDef -> EntityIdDef -> Bool # (/=) :: EntityIdDef -> EntityIdDef -> Bool #
Ord EntityIdDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: EntityIdDef -> EntityIdDef -> Ordering # (<) :: EntityIdDef -> EntityIdDef -> Bool # (<=) :: EntityIdDef -> EntityIdDef -> Bool # (>) :: EntityIdDef -> EntityIdDef -> Bool # (>=) :: EntityIdDef -> EntityIdDef -> Bool # max :: EntityIdDef -> EntityIdDef -> EntityIdDef # min :: EntityIdDef -> EntityIdDef -> EntityIdDef #
Lift EntityIdDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => EntityIdDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EntityIdDef -> Code m EntityIdDef #

type ExtraLine = [Text] #

type Attr = Text #

data FieldAttr #

Attributes that may be attached to fields that can affect migrations and serialization in backend-specific ways.

While we endeavor to, we can't forsee all use cases for all backends, and so FieldAttr is extensible through its constructor FieldAttrOther.

Since: persistent-2.11.0.0

Constructors

FieldAttrMaybe	The `Maybe` keyword goes after the type. This indicates that the column is nullable, and the generated Haskell code will have a `Maybe` type for it. Example: User name Text Maybe
FieldAttrNullable	This indicates that the column is nullable, but should not have a `Maybe` type. For this to work out, you need to ensure that the `PersistField` instance for the type in question can support a `PersistNull` value. data What = NoWhat \| Hello Text instance PersistField What where fromPersistValue PersistNull = pure NoWhat fromPersistValue pv = Hello $ fromPersistValue pv instance PersistFieldSql What where sqlType _ = SqlString User what What nullable
FieldAttrMigrationOnly	This tag means that the column will not be present on the Haskell code, but will not be removed from the database. Useful to deprecate fields in phases. You should set the column to be nullable in the database. Otherwise, inserts won't have values. User oldName Text MigrationOnly newName Text
FieldAttrSafeToRemove	A `SafeToRemove` attribute is not present on the Haskell datatype, and the backend migrations should attempt to drop the column without triggering any unsafe migration warnings. Useful after you've used `MigrationOnly` to remove a column from the database in phases. User oldName Text SafeToRemove newName Text
FieldAttrNoreference	This attribute indicates that we should not create a foreign key reference from a column. By default, `persistent` will try and create a foreign key reference for a column if it can determine that the type of the column is a `Key entity` or an `EntityId` and the `Entity`'s name was present in `mkPersist`. This is useful if you want to use the explicit foreign key syntax. Post title Text Comment postId PostId noreference Foreign Post fk_comment_post postId
FieldAttrReference Text	This is set to specify precisely the database table the column refers to. Post title Text Comment postId PostId references="post" You should not need this - `persistent` should be capable of correctly determining the target table's name. If you do need this, please file an issue describing why.
FieldAttrConstraint Text	Specify a name for the constraint on the foreign key reference for this table. Post title Text Comment postId PostId constraint="my_cool_constraint_name"
FieldAttrDefault Text	Specify the default value for a column. User createdAt UTCTime default="NOW()" Note that a `default=` attribute does not mean you can omit the value while inserting.
FieldAttrSqltype Text	Specify a custom SQL type for the column. Generally, you should define a custom datatype with a custom `PersistFieldSql` instance instead of using this. User uuid Text sqltype=UUID
FieldAttrMaxlen Integer	Set a maximum length for a column. Useful for VARCHAR and indexes. User name Text maxlen=200 UniqueName name
FieldAttrSql Text	Specify the database name of the column. User blarghle Int sql="b_l_a_r_g_h_l_e" Useful for performing phased migrations, where one column is renamed to another column over time.
FieldAttrOther Text	A grab bag of random attributes that were unrecognized by the parser.

Instances

Instances details

Read FieldAttr
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS FieldAttr # readList :: ReadS [FieldAttr] # readPrec :: ReadPrec FieldAttr # readListPrec :: ReadPrec [FieldAttr] #
Show FieldAttr
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> FieldAttr -> ShowS # show :: FieldAttr -> String # showList :: [FieldAttr] -> ShowS #
Eq FieldAttr
Instance details Defined in Database.Persist.Types.Base Methods (==) :: FieldAttr -> FieldAttr -> Bool # (/=) :: FieldAttr -> FieldAttr -> Bool #
Ord FieldAttr
Instance details Defined in Database.Persist.Types.Base Methods compare :: FieldAttr -> FieldAttr -> Ordering # (<) :: FieldAttr -> FieldAttr -> Bool # (<=) :: FieldAttr -> FieldAttr -> Bool # (>) :: FieldAttr -> FieldAttr -> Bool # (>=) :: FieldAttr -> FieldAttr -> Bool # max :: FieldAttr -> FieldAttr -> FieldAttr # min :: FieldAttr -> FieldAttr -> FieldAttr #
Lift FieldAttr
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => FieldAttr -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldAttr -> Code m FieldAttr #

data FieldType #

A FieldType describes a field parsed from the QuasiQuoter and is used to determine the Haskell type in the generated code.

name Text parses into FTTypeCon Nothing Text

name T.Text parses into FTTypeCon (Just T Text)

name (Jsonb User) parses into:

FTApp (FTTypeCon Nothing Jsonb) (FTTypeCon Nothing User)

Constructors

FTTypeCon (Maybe Text) Text	Optional module and name.
FTLit FieldTypeLit
FTTypePromoted Text
FTApp FieldType FieldType
FTList FieldType

Instances

Instances details

Read FieldType
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS FieldType # readList :: ReadS [FieldType] # readPrec :: ReadPrec FieldType # readListPrec :: ReadPrec [FieldType] #
Show FieldType
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> FieldType -> ShowS # show :: FieldType -> String # showList :: [FieldType] -> ShowS #
Eq FieldType
Instance details Defined in Database.Persist.Types.Base Methods (==) :: FieldType -> FieldType -> Bool # (/=) :: FieldType -> FieldType -> Bool #
Ord FieldType
Instance details Defined in Database.Persist.Types.Base Methods compare :: FieldType -> FieldType -> Ordering # (<) :: FieldType -> FieldType -> Bool # (<=) :: FieldType -> FieldType -> Bool # (>) :: FieldType -> FieldType -> Bool # (>=) :: FieldType -> FieldType -> Bool # max :: FieldType -> FieldType -> FieldType # min :: FieldType -> FieldType -> FieldType #
Lift FieldType
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => FieldType -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldType -> Code m FieldType #

data ReferenceDef #

There are 3 kinds of references 1) composite (to fields that exist in the record) 2) single field 3) embedded

Constructors

NoReference
ForeignRef !EntityNameHS	A ForeignRef has a late binding to the EntityDef it references via name and has the Haskell type of the foreign key in the form of FieldType
EmbedRef EntityNameHS
SelfReference	A SelfReference stops an immediate cycle which causes non-termination at compile-time (issue #311).

Instances

Instances details

Read ReferenceDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS ReferenceDef # readList :: ReadS [ReferenceDef] # readPrec :: ReadPrec ReferenceDef # readListPrec :: ReadPrec [ReferenceDef] #
Show ReferenceDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> ReferenceDef -> ShowS # show :: ReferenceDef -> String # showList :: [ReferenceDef] -> ShowS #
Eq ReferenceDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: ReferenceDef -> ReferenceDef -> Bool # (/=) :: ReferenceDef -> ReferenceDef -> Bool #
Ord ReferenceDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: ReferenceDef -> ReferenceDef -> Ordering # (<) :: ReferenceDef -> ReferenceDef -> Bool # (<=) :: ReferenceDef -> ReferenceDef -> Bool # (>) :: ReferenceDef -> ReferenceDef -> Bool # (>=) :: ReferenceDef -> ReferenceDef -> Bool # max :: ReferenceDef -> ReferenceDef -> ReferenceDef # min :: ReferenceDef -> ReferenceDef -> ReferenceDef #
Lift ReferenceDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => ReferenceDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ReferenceDef -> Code m ReferenceDef #

data EmbedEntityDef #

An EmbedEntityDef is the same as an EntityDef But it is only used for fieldReference so it only has data needed for embedding

Constructors

EmbedEntityDef
Fields embeddedHaskell :: EntityNameHS embeddedFields :: [EmbedFieldDef]

Instances

Instances details

Read EmbedEntityDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EmbedEntityDef # readList :: ReadS [EmbedEntityDef] # readPrec :: ReadPrec EmbedEntityDef # readListPrec :: ReadPrec [EmbedEntityDef] #
Show EmbedEntityDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EmbedEntityDef -> ShowS # show :: EmbedEntityDef -> String # showList :: [EmbedEntityDef] -> ShowS #
Eq EmbedEntityDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (/=) :: EmbedEntityDef -> EmbedEntityDef -> Bool #
Ord EmbedEntityDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: EmbedEntityDef -> EmbedEntityDef -> Ordering # (<) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (<=) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (>) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (>=) :: EmbedEntityDef -> EmbedEntityDef -> Bool # max :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef # min :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef #
Lift EmbedEntityDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => EmbedEntityDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EmbedEntityDef -> Code m EmbedEntityDef #

data EmbedFieldDef #

An EmbedFieldDef is the same as a FieldDef But it is only used for embeddedFields so it only has data needed for embedding

Constructors

EmbedFieldDef
Fields emFieldDB :: FieldNameDB emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)

Instances

Instances details

Read EmbedFieldDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EmbedFieldDef # readList :: ReadS [EmbedFieldDef] # readPrec :: ReadPrec EmbedFieldDef # readListPrec :: ReadPrec [EmbedFieldDef] #
Show EmbedFieldDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EmbedFieldDef -> ShowS # show :: EmbedFieldDef -> String # showList :: [EmbedFieldDef] -> ShowS #
Eq EmbedFieldDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (/=) :: EmbedFieldDef -> EmbedFieldDef -> Bool #
Ord EmbedFieldDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: EmbedFieldDef -> EmbedFieldDef -> Ordering # (<) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (<=) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (>) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (>=) :: EmbedFieldDef -> EmbedFieldDef -> Bool # max :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef # min :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef #
Lift EmbedFieldDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => EmbedFieldDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EmbedFieldDef -> Code m EmbedFieldDef #

data UniqueDef #

Type for storing the Uniqueness constraint in the Schema. Assume you have the following schema with a uniqueness constraint:

Person
  name String
  age Int
  UniqueAge age

This will be represented as:

UniqueDef
    { uniqueHaskell = ConstraintNameHS (packPTH UniqueAge)
    , uniqueDBName = ConstraintNameDB (packPTH "unique_age")
    , uniqueFields = [(FieldNameHS (packPTH "age"), FieldNameDB (packPTH "age"))]
    , uniqueAttrs = []
    }

Constructors

UniqueDef
Fields uniqueHaskell :: !ConstraintNameHS uniqueDBName :: !ConstraintNameDB uniqueFields :: !(NonEmpty (FieldNameHS, FieldNameDB)) uniqueAttrs :: ![Attr]

Instances

Instances details

Read UniqueDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS UniqueDef # readList :: ReadS [UniqueDef] # readPrec :: ReadPrec UniqueDef # readListPrec :: ReadPrec [UniqueDef] #
Show UniqueDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> UniqueDef -> ShowS # show :: UniqueDef -> String # showList :: [UniqueDef] -> ShowS #
Eq UniqueDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: UniqueDef -> UniqueDef -> Bool # (/=) :: UniqueDef -> UniqueDef -> Bool #
Ord UniqueDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: UniqueDef -> UniqueDef -> Ordering # (<) :: UniqueDef -> UniqueDef -> Bool # (<=) :: UniqueDef -> UniqueDef -> Bool # (>) :: UniqueDef -> UniqueDef -> Bool # (>=) :: UniqueDef -> UniqueDef -> Bool # max :: UniqueDef -> UniqueDef -> UniqueDef # min :: UniqueDef -> UniqueDef -> UniqueDef #
Lift UniqueDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => UniqueDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => UniqueDef -> Code m UniqueDef #

data CompositeDef #

Constructors

CompositeDef
Fields compositeFields :: !(NonEmpty FieldDef) compositeAttrs :: ![Attr]

Instances

Instances details

Read CompositeDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS CompositeDef # readList :: ReadS [CompositeDef] # readPrec :: ReadPrec CompositeDef # readListPrec :: ReadPrec [CompositeDef] #
Show CompositeDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> CompositeDef -> ShowS # show :: CompositeDef -> String # showList :: [CompositeDef] -> ShowS #
Eq CompositeDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: CompositeDef -> CompositeDef -> Bool # (/=) :: CompositeDef -> CompositeDef -> Bool #
Ord CompositeDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: CompositeDef -> CompositeDef -> Ordering # (<) :: CompositeDef -> CompositeDef -> Bool # (<=) :: CompositeDef -> CompositeDef -> Bool # (>) :: CompositeDef -> CompositeDef -> Bool # (>=) :: CompositeDef -> CompositeDef -> Bool # max :: CompositeDef -> CompositeDef -> CompositeDef # min :: CompositeDef -> CompositeDef -> CompositeDef #
Lift CompositeDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => CompositeDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => CompositeDef -> Code m CompositeDef #

type ForeignFieldDef = (FieldNameHS, FieldNameDB) #

Used instead of FieldDef to generate a smaller amount of code

data ForeignDef #

Constructors

ForeignDef

Fields

foreignRefTableHaskell :: !EntityNameHS
foreignRefTableDBName :: !EntityNameDB
foreignConstraintNameHaskell :: !ConstraintNameHS
foreignConstraintNameDBName :: !ConstraintNameDB
foreignFieldCascade :: !FieldCascade
Determine how the field will cascade on updates and deletions.
Since: persistent-2.11.0
foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)]
foreignAttrs :: ![Attr]
foreignNullable :: Bool
foreignToPrimary :: Bool
Determines if the reference is towards a Primary Key or not.
Since: persistent-2.11.0

Instances

Instances details

Read ForeignDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS ForeignDef # readList :: ReadS [ForeignDef] # readPrec :: ReadPrec ForeignDef # readListPrec :: ReadPrec [ForeignDef] #
Show ForeignDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> ForeignDef -> ShowS # show :: ForeignDef -> String # showList :: [ForeignDef] -> ShowS #
Eq ForeignDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: ForeignDef -> ForeignDef -> Bool # (/=) :: ForeignDef -> ForeignDef -> Bool #
Ord ForeignDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: ForeignDef -> ForeignDef -> Ordering # (<) :: ForeignDef -> ForeignDef -> Bool # (<=) :: ForeignDef -> ForeignDef -> Bool # (>) :: ForeignDef -> ForeignDef -> Bool # (>=) :: ForeignDef -> ForeignDef -> Bool # max :: ForeignDef -> ForeignDef -> ForeignDef # min :: ForeignDef -> ForeignDef -> ForeignDef #
Lift ForeignDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => ForeignDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ForeignDef -> Code m ForeignDef #

data FieldCascade #

This datatype describes how a foreign reference field cascades deletes or updates.

This type is used in both parsing the model definitions and performing migrations. A Nothing in either of the field values means that the user has not specified a CascadeAction. An unspecified CascadeAction is defaulted to Restrict when doing migrations.

Since: persistent-2.11.0

Constructors

FieldCascade
Fields fcOnUpdate :: !(Maybe CascadeAction) fcOnDelete :: !(Maybe CascadeAction)

Instances

Instances details

Read FieldCascade
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS FieldCascade # readList :: ReadS [FieldCascade] # readPrec :: ReadPrec FieldCascade # readListPrec :: ReadPrec [FieldCascade] #
Show FieldCascade
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> FieldCascade -> ShowS # show :: FieldCascade -> String # showList :: [FieldCascade] -> ShowS #
Eq FieldCascade
Instance details Defined in Database.Persist.Types.Base Methods (==) :: FieldCascade -> FieldCascade -> Bool # (/=) :: FieldCascade -> FieldCascade -> Bool #
Ord FieldCascade
Instance details Defined in Database.Persist.Types.Base Methods compare :: FieldCascade -> FieldCascade -> Ordering # (<) :: FieldCascade -> FieldCascade -> Bool # (<=) :: FieldCascade -> FieldCascade -> Bool # (>) :: FieldCascade -> FieldCascade -> Bool # (>=) :: FieldCascade -> FieldCascade -> Bool # max :: FieldCascade -> FieldCascade -> FieldCascade # min :: FieldCascade -> FieldCascade -> FieldCascade #
Lift FieldCascade
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => FieldCascade -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldCascade -> Code m FieldCascade #

data CascadeAction #

An action that might happen on a deletion or update on a foreign key change.

Since: persistent-2.11.0

Constructors

Cascade
Restrict
SetNull
SetDefault

Instances

Instances details

Read CascadeAction
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS CascadeAction # readList :: ReadS [CascadeAction] # readPrec :: ReadPrec CascadeAction # readListPrec :: ReadPrec [CascadeAction] #
Show CascadeAction
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> CascadeAction -> ShowS # show :: CascadeAction -> String # showList :: [CascadeAction] -> ShowS #
Eq CascadeAction
Instance details Defined in Database.Persist.Types.Base Methods (==) :: CascadeAction -> CascadeAction -> Bool # (/=) :: CascadeAction -> CascadeAction -> Bool #
Ord CascadeAction
Instance details Defined in Database.Persist.Types.Base Methods compare :: CascadeAction -> CascadeAction -> Ordering # (<) :: CascadeAction -> CascadeAction -> Bool # (<=) :: CascadeAction -> CascadeAction -> Bool # (>) :: CascadeAction -> CascadeAction -> Bool # (>=) :: CascadeAction -> CascadeAction -> Bool # max :: CascadeAction -> CascadeAction -> CascadeAction # min :: CascadeAction -> CascadeAction -> CascadeAction #
Lift CascadeAction
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => CascadeAction -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => CascadeAction -> Code m CascadeAction #

data PersistException #

Constructors

PersistError Text	Generic Exception
PersistMarshalError Text
PersistInvalidField Text
PersistForeignConstraintUnmet Text
PersistMongoDBError Text
PersistMongoDBUnsupported Text

Instances

Instances details

Exception PersistException
Instance details Defined in Database.Persist.Types.Base Methods toException :: PersistException -> SomeException # fromException :: SomeException -> Maybe PersistException # displayException :: PersistException -> String #
Show PersistException
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistException -> ShowS # show :: PersistException -> String # showList :: [PersistException] -> ShowS #

data SqlType #

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.

Constructors

SqlString
SqlInt32
SqlInt64
SqlReal
SqlNumeric Word32 Word32
SqlBool
SqlDay
SqlTime
SqlDayTime	Always uses UTC timezone
SqlBlob
SqlOther Text	a backend-specific name

Instances

Instances details

Read SqlType
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS SqlType # readList :: ReadS [SqlType] # readPrec :: ReadPrec SqlType # readListPrec :: ReadPrec [SqlType] #
Show SqlType
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> SqlType -> ShowS # show :: SqlType -> String # showList :: [SqlType] -> ShowS #
Eq SqlType
Instance details Defined in Database.Persist.Types.Base Methods (==) :: SqlType -> SqlType -> Bool # (/=) :: SqlType -> SqlType -> Bool #
Ord SqlType
Instance details Defined in Database.Persist.Types.Base Methods compare :: SqlType -> SqlType -> Ordering # (<) :: SqlType -> SqlType -> Bool # (<=) :: SqlType -> SqlType -> Bool # (>) :: SqlType -> SqlType -> Bool # (>=) :: SqlType -> SqlType -> Bool # max :: SqlType -> SqlType -> SqlType # min :: SqlType -> SqlType -> SqlType #
Lift SqlType
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => SqlType -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => SqlType -> Code m SqlType #

data PersistFilter #

Constructors

Eq
Ne
Gt
Lt
Ge
Le
In
NotIn
BackendSpecificFilter Text

Instances

Instances details

Read PersistFilter
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS PersistFilter # readList :: ReadS [PersistFilter] # readPrec :: ReadPrec PersistFilter # readListPrec :: ReadPrec [PersistFilter] #
Show PersistFilter
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistFilter -> ShowS # show :: PersistFilter -> String # showList :: [PersistFilter] -> ShowS #
Lift PersistFilter
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => PersistFilter -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => PersistFilter -> Code m PersistFilter #

data UpdateException #

Constructors

KeyNotFound String
UpsertError String

Instances

Instances details

Exception UpdateException
Instance details Defined in Database.Persist.Types.Base Methods toException :: UpdateException -> SomeException # fromException :: SomeException -> Maybe UpdateException # displayException :: UpdateException -> String #
Show UpdateException
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> UpdateException -> ShowS # show :: UpdateException -> String # showList :: [UpdateException] -> ShowS #

data PersistUpdate #

Constructors

Assign
Add
Subtract
Multiply
Divide
BackendSpecificUpdate Text

Instances

Instances details

Read PersistUpdate
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS PersistUpdate # readList :: ReadS [PersistUpdate] # readPrec :: ReadPrec PersistUpdate # readListPrec :: ReadPrec [PersistUpdate] #
Show PersistUpdate
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistUpdate -> ShowS # show :: PersistUpdate -> String # showList :: [PersistUpdate] -> ShowS #
Lift PersistUpdate
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => PersistUpdate -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => PersistUpdate -> Code m PersistUpdate #

data FieldDef #

A FieldDef represents the inormation that persistent knows about a field of a datatype. This includes information used to parse the field out of the database and what the field corresponds to.

Constructors

FieldDef

Fields

fieldHaskell :: !FieldNameHS
The name of the field. Note that this does not corresponds to the record labels generated for the particular entity - record labels are generated with the type name prefixed to the field, so a FieldDef that contains a FieldNameHS "name" for a type User will have a record field userName.
fieldDB :: !FieldNameDB
The name of the field in the database. For SQL databases, this corresponds to the column name.
fieldType :: !FieldType
The type of the field in Haskell.
fieldSqlType :: !SqlType
The type of the field in a SQL database.
fieldAttrs :: ![FieldAttr]
User annotations for a field. These are provided with the ! operator.
fieldStrict :: !Bool
If this is True, then the Haskell datatype will have a strict record field. The default value for this is True.
fieldReference :: !ReferenceDef
fieldCascade :: !FieldCascade
Defines how operations on the field cascade on to the referenced tables. This doesn't have any meaning if the fieldReference is set to NoReference or SelfReference. The cascade option here should be the same as the one obtained in the fieldReference.
Since: persistent-2.11.0
fieldComments :: !(Maybe Text)
Optional comments for a Field.
Since: persistent-2.10.0
fieldGenerated :: !(Maybe Text)
Whether or not the field is a GENERATED column, and additionally the expression to use for generation.
Since: persistent-2.11.0.0
fieldIsImplicitIdColumn :: !Bool
True if the field is an implicit ID column. False otherwise.
Since: persistent-2.13.0.0

Instances

Instances details

Read FieldDef
Instance details Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS FieldDef # readList :: ReadS [FieldDef] # readPrec :: ReadPrec FieldDef # readListPrec :: ReadPrec [FieldDef] #
Show FieldDef
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> FieldDef -> ShowS # show :: FieldDef -> String # showList :: [FieldDef] -> ShowS #
Eq FieldDef
Instance details Defined in Database.Persist.Types.Base Methods (==) :: FieldDef -> FieldDef -> Bool # (/=) :: FieldDef -> FieldDef -> Bool #
Ord FieldDef
Instance details Defined in Database.Persist.Types.Base Methods compare :: FieldDef -> FieldDef -> Ordering # (<) :: FieldDef -> FieldDef -> Bool # (<=) :: FieldDef -> FieldDef -> Bool # (>) :: FieldDef -> FieldDef -> Bool # (>=) :: FieldDef -> FieldDef -> Bool # max :: FieldDef -> FieldDef -> FieldDef # min :: FieldDef -> FieldDef -> FieldDef #
Lift FieldDef
Instance details Defined in Database.Persist.Types.Base Methods lift :: Quote m => FieldDef -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldDef -> Code m FieldDef #

data IsolationLevel #

Please refer to the documentation for the database in question for a full overview of the semantics of the varying isloation levels

Constructors

ReadUncommitted
ReadCommitted
RepeatableRead
Serializable

Instances

Instances details

Bounded IsolationLevel
Instance details Defined in Database.Persist.SqlBackend.Internal.IsolationLevel Methods minBound :: IsolationLevel # maxBound :: IsolationLevel #
Enum IsolationLevel
Instance details Defined in Database.Persist.SqlBackend.Internal.IsolationLevel Methods succ :: IsolationLevel -> IsolationLevel # pred :: IsolationLevel -> IsolationLevel # toEnum :: Int -> IsolationLevel # fromEnum :: IsolationLevel -> Int # enumFrom :: IsolationLevel -> [IsolationLevel] # enumFromThen :: IsolationLevel -> IsolationLevel -> [IsolationLevel] # enumFromTo :: IsolationLevel -> IsolationLevel -> [IsolationLevel] # enumFromThenTo :: IsolationLevel -> IsolationLevel -> IsolationLevel -> [IsolationLevel] #
Show IsolationLevel
Instance details Defined in Database.Persist.SqlBackend.Internal.IsolationLevel Methods showsPrec :: Int -> IsolationLevel -> ShowS # show :: IsolationLevel -> String # showList :: [IsolationLevel] -> ShowS #
Eq IsolationLevel
Instance details Defined in Database.Persist.SqlBackend.Internal.IsolationLevel Methods (==) :: IsolationLevel -> IsolationLevel -> Bool # (/=) :: IsolationLevel -> IsolationLevel -> Bool #
Ord IsolationLevel
Instance details Defined in Database.Persist.SqlBackend.Internal.IsolationLevel Methods compare :: IsolationLevel -> IsolationLevel -> Ordering # (<) :: IsolationLevel -> IsolationLevel -> Bool # (<=) :: IsolationLevel -> IsolationLevel -> Bool # (>) :: IsolationLevel -> IsolationLevel -> Bool # (>=) :: IsolationLevel -> IsolationLevel -> Bool # max :: IsolationLevel -> IsolationLevel -> IsolationLevel # min :: IsolationLevel -> IsolationLevel -> IsolationLevel #

fromPersistValueText :: PersistValue -> Either Text Text #

data PersistValue #

A raw value which can be stored in any backend and can be marshalled to and from a PersistField.

Constructors

PersistText Text
PersistByteString ByteString
PersistInt64 Int64
PersistDouble Double
PersistRational Rational
PersistBool Bool
PersistDay Day
PersistTimeOfDay TimeOfDay
PersistUTCTime UTCTime
PersistNull
PersistList [PersistValue]
PersistMap [(Text, PersistValue)]
PersistObjectId ByteString	Intended especially for MongoDB backend
PersistArray [PersistValue]	Intended especially for PostgreSQL backend for text arrays
PersistLiteral_ LiteralType ByteString	This constructor is used to specify some raw literal value for the backend. The `LiteralType` value specifies how the value should be escaped. This can be used to make special, custom types avaialable in the back end. Since: persistent-2.12.0.0

Bundled Patterns

pattern PersistDbSpecific :: ByteString -> PersistValue

This pattern synonym used to be a data constructor for the PersistValue type. It was changed to be a pattern so that JSON-encoded database values could be parsed into their corresponding values. You should not use this, and instead prefer to pattern match on PersistLiteral_ directly.

If you use this, it will overlap a patern match on the 'PersistLiteral_, PersistLiteral, and PersistLiteralEscaped patterns. If you need to disambiguate between these constructors, pattern match on PersistLiteral_ directly.

Since: persistent-2.12.0.0

pattern PersistLiteralEscaped :: ByteString -> PersistValue

This pattern synonym used to be a data constructor on PersistValue, but was changed into a catch-all pattern synonym to allow backwards compatiblity with database types. See the documentation on PersistDbSpecific for more details.

Since: persistent-2.12.0.0

pattern PersistLiteral :: ByteString -> PersistValue

This pattern synonym used to be a data constructor on PersistValue, but was changed into a catch-all pattern synonym to allow backwards compatiblity with database types. See the documentation on PersistDbSpecific for more details.

Since: persistent-2.12.0.0

Instances

Instances details

FromJSON PersistValue
Instance details Defined in Database.Persist.PersistValue Methods parseJSON :: Value -> Parser PersistValue # parseJSONList :: Value -> Parser [PersistValue] #
ToJSON PersistValue
Instance details Defined in Database.Persist.PersistValue Methods toJSON :: PersistValue -> Value # toEncoding :: PersistValue -> Encoding # toJSONList :: [PersistValue] -> Value # toEncodingList :: [PersistValue] -> Encoding #
Read PersistValue
Instance details Defined in Database.Persist.PersistValue Methods readsPrec :: Int -> ReadS PersistValue # readList :: ReadS [PersistValue] # readPrec :: ReadPrec PersistValue # readListPrec :: ReadPrec [PersistValue] #
Show PersistValue
Instance details Defined in Database.Persist.PersistValue Methods showsPrec :: Int -> PersistValue -> ShowS # show :: PersistValue -> String # showList :: [PersistValue] -> ShowS #
NFData PersistValue	Since: persistent-2.14.4.0
Instance details Defined in Database.Persist.PersistValue Methods rnf :: PersistValue -> () #
Eq PersistValue
Instance details Defined in Database.Persist.PersistValue Methods (==) :: PersistValue -> PersistValue -> Bool # (/=) :: PersistValue -> PersistValue -> Bool #
Ord PersistValue
Instance details Defined in Database.Persist.PersistValue Methods compare :: PersistValue -> PersistValue -> Ordering # (<) :: PersistValue -> PersistValue -> Bool # (<=) :: PersistValue -> PersistValue -> Bool # (>) :: PersistValue -> PersistValue -> Bool # (>=) :: PersistValue -> PersistValue -> Bool # max :: PersistValue -> PersistValue -> PersistValue # min :: PersistValue -> PersistValue -> PersistValue #
FromHttpApiData PersistValue
Instance details Defined in Database.Persist.PersistValue Methods parseUrlPiece :: Text -> Either Text PersistValue # parseHeader :: ByteString -> Either Text PersistValue # parseQueryParam :: Text -> Either Text PersistValue #
ToHttpApiData PersistValue
Instance details Defined in Database.Persist.PersistValue Methods toUrlPiece :: PersistValue -> Text # toEncodedUrlPiece :: PersistValue -> Builder # toHeader :: PersistValue -> ByteString # toQueryParam :: PersistValue -> Text # toEncodedQueryParam :: PersistValue -> Builder #
PathPiece PersistValue
Instance details Defined in Database.Persist.PersistValue Methods fromPathPiece :: Text -> Maybe PersistValue # toPathPiece :: PersistValue -> Text #
PersistField PersistValue
Instance details Defined in Database.Persist.Class.PersistField Methods toPersistValue :: PersistValue -> PersistValue # fromPersistValue :: PersistValue -> Either Text PersistValue #
PersistFieldSql PersistValue
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy PersistValue -> SqlType #

data LiteralType #

A type that determines how a backend should handle the literal.

Since: persistent-2.12.0.0

Constructors

Escaped

The accompanying value will be escaped before inserting into the database. This is the correct default choice to use.

Since: persistent-2.12.0.0

Unescaped

The accompanying value will not be escaped when inserting into the database. This is potentially dangerous - use this with care.

Since: persistent-2.12.0.0

DbSpecific

The DbSpecific constructor corresponds to the legacy PersistDbSpecific constructor. We need to keep this around because old databases may have serialized JSON representations that reference this. We don't want to break the ability of a database to load rows.

Since: persistent-2.12.0.0

Instances

Instances details

Read LiteralType
Instance details Defined in Database.Persist.PersistValue Methods readsPrec :: Int -> ReadS LiteralType # readList :: ReadS [LiteralType] # readPrec :: ReadPrec LiteralType # readListPrec :: ReadPrec [LiteralType] #
Show LiteralType
Instance details Defined in Database.Persist.PersistValue Methods showsPrec :: Int -> LiteralType -> ShowS # show :: LiteralType -> String # showList :: [LiteralType] -> ShowS #
Eq LiteralType
Instance details Defined in Database.Persist.PersistValue Methods (==) :: LiteralType -> LiteralType -> Bool # (/=) :: LiteralType -> LiteralType -> Bool #
Ord LiteralType
Instance details Defined in Database.Persist.PersistValue Methods compare :: LiteralType -> LiteralType -> Ordering # (<) :: LiteralType -> LiteralType -> Bool # (<=) :: LiteralType -> LiteralType -> Bool # (>) :: LiteralType -> LiteralType -> Bool # (>=) :: LiteralType -> LiteralType -> Bool # max :: LiteralType -> LiteralType -> LiteralType # min :: LiteralType -> LiteralType -> LiteralType #

class DatabaseName a where #

Convenience operations for working with '-NameDB' types.

Since: persistent-2.12.0.0

Methods

escapeWith :: (Text -> str) -> a -> str #

Instances

Instances details

DatabaseName ConstraintNameDB	Since: persistent-2.12.0.0
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> ConstraintNameDB -> str #
DatabaseName EntityNameDB
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> EntityNameDB -> str #
DatabaseName FieldNameDB	Since: persistent-2.12.0.0
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> FieldNameDB -> str #

newtype FieldNameDB #

A FieldNameDB represents the datastore-side name that persistent will use for a field.

Since: persistent-2.12.0.0

Constructors

FieldNameDB
Fields unFieldNameDB :: Text

Instances

Instances details

Read FieldNameDB
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS FieldNameDB # readList :: ReadS [FieldNameDB] # readPrec :: ReadPrec FieldNameDB # readListPrec :: ReadPrec [FieldNameDB] #
Show FieldNameDB
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> FieldNameDB -> ShowS # show :: FieldNameDB -> String # showList :: [FieldNameDB] -> ShowS #
Eq FieldNameDB
Instance details Defined in Database.Persist.Names Methods (==) :: FieldNameDB -> FieldNameDB -> Bool # (/=) :: FieldNameDB -> FieldNameDB -> Bool #
Ord FieldNameDB
Instance details Defined in Database.Persist.Names Methods compare :: FieldNameDB -> FieldNameDB -> Ordering # (<) :: FieldNameDB -> FieldNameDB -> Bool # (<=) :: FieldNameDB -> FieldNameDB -> Bool # (>) :: FieldNameDB -> FieldNameDB -> Bool # (>=) :: FieldNameDB -> FieldNameDB -> Bool # max :: FieldNameDB -> FieldNameDB -> FieldNameDB # min :: FieldNameDB -> FieldNameDB -> FieldNameDB #
DatabaseName FieldNameDB	Since: persistent-2.12.0.0
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> FieldNameDB -> str #
Lift FieldNameDB
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => FieldNameDB -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldNameDB -> Code m FieldNameDB #

newtype FieldNameHS #

A FieldNameHS represents the Haskell-side name that persistent will use for a field.

Since: persistent-2.12.0.0

Constructors

FieldNameHS
Fields unFieldNameHS :: Text

Instances

Instances details

Read FieldNameHS
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS FieldNameHS # readList :: ReadS [FieldNameHS] # readPrec :: ReadPrec FieldNameHS # readListPrec :: ReadPrec [FieldNameHS] #
Show FieldNameHS
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> FieldNameHS -> ShowS # show :: FieldNameHS -> String # showList :: [FieldNameHS] -> ShowS #
Eq FieldNameHS
Instance details Defined in Database.Persist.Names Methods (==) :: FieldNameHS -> FieldNameHS -> Bool # (/=) :: FieldNameHS -> FieldNameHS -> Bool #
Ord FieldNameHS
Instance details Defined in Database.Persist.Names Methods compare :: FieldNameHS -> FieldNameHS -> Ordering # (<) :: FieldNameHS -> FieldNameHS -> Bool # (<=) :: FieldNameHS -> FieldNameHS -> Bool # (>) :: FieldNameHS -> FieldNameHS -> Bool # (>=) :: FieldNameHS -> FieldNameHS -> Bool # max :: FieldNameHS -> FieldNameHS -> FieldNameHS # min :: FieldNameHS -> FieldNameHS -> FieldNameHS #
Lift FieldNameHS
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => FieldNameHS -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FieldNameHS -> Code m FieldNameHS #

newtype EntityNameHS #

An EntityNameHS represents the Haskell-side name that persistent will use for an entity.

Since: persistent-2.12.0.0

Constructors

EntityNameHS
Fields unEntityNameHS :: Text

Instances

Instances details

Read EntityNameHS
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS EntityNameHS # readList :: ReadS [EntityNameHS] # readPrec :: ReadPrec EntityNameHS # readListPrec :: ReadPrec [EntityNameHS] #
Show EntityNameHS
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> EntityNameHS -> ShowS # show :: EntityNameHS -> String # showList :: [EntityNameHS] -> ShowS #
Eq EntityNameHS
Instance details Defined in Database.Persist.Names Methods (==) :: EntityNameHS -> EntityNameHS -> Bool # (/=) :: EntityNameHS -> EntityNameHS -> Bool #
Ord EntityNameHS
Instance details Defined in Database.Persist.Names Methods compare :: EntityNameHS -> EntityNameHS -> Ordering # (<) :: EntityNameHS -> EntityNameHS -> Bool # (<=) :: EntityNameHS -> EntityNameHS -> Bool # (>) :: EntityNameHS -> EntityNameHS -> Bool # (>=) :: EntityNameHS -> EntityNameHS -> Bool # max :: EntityNameHS -> EntityNameHS -> EntityNameHS # min :: EntityNameHS -> EntityNameHS -> EntityNameHS #
Lift EntityNameHS
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => EntityNameHS -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EntityNameHS -> Code m EntityNameHS #

newtype EntityNameDB #

An EntityNameDB represents the datastore-side name that persistent will use for an entity.

Since: persistent-2.12.0.0

Constructors

EntityNameDB
Fields unEntityNameDB :: Text

Instances

Instances details

Read EntityNameDB
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS EntityNameDB # readList :: ReadS [EntityNameDB] # readPrec :: ReadPrec EntityNameDB # readListPrec :: ReadPrec [EntityNameDB] #
Show EntityNameDB
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> EntityNameDB -> ShowS # show :: EntityNameDB -> String # showList :: [EntityNameDB] -> ShowS #
Eq EntityNameDB
Instance details Defined in Database.Persist.Names Methods (==) :: EntityNameDB -> EntityNameDB -> Bool # (/=) :: EntityNameDB -> EntityNameDB -> Bool #
Ord EntityNameDB
Instance details Defined in Database.Persist.Names Methods compare :: EntityNameDB -> EntityNameDB -> Ordering # (<) :: EntityNameDB -> EntityNameDB -> Bool # (<=) :: EntityNameDB -> EntityNameDB -> Bool # (>) :: EntityNameDB -> EntityNameDB -> Bool # (>=) :: EntityNameDB -> EntityNameDB -> Bool # max :: EntityNameDB -> EntityNameDB -> EntityNameDB # min :: EntityNameDB -> EntityNameDB -> EntityNameDB #
DatabaseName EntityNameDB
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> EntityNameDB -> str #
Lift EntityNameDB
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => EntityNameDB -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => EntityNameDB -> Code m EntityNameDB #

newtype ConstraintNameDB #

A ConstraintNameDB represents the datastore-side name that persistent will use for a constraint.

Since: persistent-2.12.0.0

Constructors

ConstraintNameDB
Fields unConstraintNameDB :: Text

Instances

Instances details

Read ConstraintNameDB
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS ConstraintNameDB # readList :: ReadS [ConstraintNameDB] # readPrec :: ReadPrec ConstraintNameDB # readListPrec :: ReadPrec [ConstraintNameDB] #
Show ConstraintNameDB
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> ConstraintNameDB -> ShowS # show :: ConstraintNameDB -> String # showList :: [ConstraintNameDB] -> ShowS #
Eq ConstraintNameDB
Instance details Defined in Database.Persist.Names Methods (==) :: ConstraintNameDB -> ConstraintNameDB -> Bool # (/=) :: ConstraintNameDB -> ConstraintNameDB -> Bool #
Ord ConstraintNameDB
Instance details Defined in Database.Persist.Names Methods compare :: ConstraintNameDB -> ConstraintNameDB -> Ordering # (<) :: ConstraintNameDB -> ConstraintNameDB -> Bool # (<=) :: ConstraintNameDB -> ConstraintNameDB -> Bool # (>) :: ConstraintNameDB -> ConstraintNameDB -> Bool # (>=) :: ConstraintNameDB -> ConstraintNameDB -> Bool # max :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB # min :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB #
DatabaseName ConstraintNameDB	Since: persistent-2.12.0.0
Instance details Defined in Database.Persist.Names Methods escapeWith :: (Text -> str) -> ConstraintNameDB -> str #
Lift ConstraintNameDB
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => ConstraintNameDB -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ConstraintNameDB -> Code m ConstraintNameDB #

newtype ConstraintNameHS #

An ConstraintNameHS represents the Haskell-side name that persistent will use for a constraint.

Since: persistent-2.12.0.0

Constructors

ConstraintNameHS
Fields unConstraintNameHS :: Text

Instances

Instances details

Read ConstraintNameHS
Instance details Defined in Database.Persist.Names Methods readsPrec :: Int -> ReadS ConstraintNameHS # readList :: ReadS [ConstraintNameHS] # readPrec :: ReadPrec ConstraintNameHS # readListPrec :: ReadPrec [ConstraintNameHS] #
Show ConstraintNameHS
Instance details Defined in Database.Persist.Names Methods showsPrec :: Int -> ConstraintNameHS -> ShowS # show :: ConstraintNameHS -> String # showList :: [ConstraintNameHS] -> ShowS #
Eq ConstraintNameHS
Instance details Defined in Database.Persist.Names Methods (==) :: ConstraintNameHS -> ConstraintNameHS -> Bool # (/=) :: ConstraintNameHS -> ConstraintNameHS -> Bool #
Ord ConstraintNameHS
Instance details Defined in Database.Persist.Names Methods compare :: ConstraintNameHS -> ConstraintNameHS -> Ordering # (<) :: ConstraintNameHS -> ConstraintNameHS -> Bool # (<=) :: ConstraintNameHS -> ConstraintNameHS -> Bool # (>) :: ConstraintNameHS -> ConstraintNameHS -> Bool # (>=) :: ConstraintNameHS -> ConstraintNameHS -> Bool # max :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS # min :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS #
Lift ConstraintNameHS
Instance details Defined in Database.Persist.Names Methods lift :: Quote m => ConstraintNameHS -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ConstraintNameHS -> Code m ConstraintNameHS #

type family PersistConfigPool c #

Instances

Instances details

type PersistConfigPool (Either c1 c2)
Instance details Defined in Database.Persist.Class.PersistConfig type PersistConfigPool (Either c1 c2) = PersistConfigPool c1

type family PersistConfigBackend c :: (Type -> Type) -> Type -> Type #

Instances

Instances details

type PersistConfigBackend (Either c1 c2)
Instance details Defined in Database.Persist.Class.PersistConfig type PersistConfigBackend (Either c1 c2) = PersistConfigBackend c1

class PersistConfig c where #

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.

Minimal complete definition

loadConfig, createPoolConfig, runPool

Associated Types

type PersistConfigBackend c :: (Type -> Type) -> Type -> Type #

type PersistConfigPool c #

Methods

loadConfig :: Value -> Parser c #

Load the config settings from a Value, most likely taken from a YAML config file.

applyEnv :: c -> IO c #

Modify the config settings based on environment variables.

createPoolConfig :: c -> IO (PersistConfigPool c) #

Create a new connection pool based on the given config settings.

runPool :: MonadUnliftIO m => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a #

Run a database action by taking a connection from the pool.

Instances

Instances details

(PersistConfig c1, PersistConfig c2, PersistConfigPool c1 ~ PersistConfigPool c2, PersistConfigBackend c1 ~ PersistConfigBackend c2) => PersistConfig (Either c1 c2)

Instance details

Defined in Database.Persist.Class.PersistConfig

Associated Types

type PersistConfigBackend (Either c1 c2) :: (Type -> Type) -> Type -> Type #

type PersistConfigPool (Either c1 c2) #

Methods

loadConfig :: Value -> Parser (Either c1 c2) #

applyEnv :: Either c1 c2 -> IO (Either c1 c2) #

createPoolConfig :: Either c1 c2 -> IO (PersistConfigPool (Either c1 c2)) #

runPool :: MonadUnliftIO m => Either c1 c2 -> PersistConfigBackend (Either c1 c2) m a -> PersistConfigPool (Either c1 c2) -> m a #

get :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe record) Source #

The lifted version of get

getMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Key record] -> m (Map (Key record) record) Source #

The lifted version of getMany

getJust :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m record Source #

The lifted version of getJust

getJustEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Entity record) Source #

The lifted version of getJustEntity

getEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe (Entity record)) Source #

The lifted version of getEntity

belongsTo :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2) Source #

The lifted version of belongsTo

belongsToJust :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Key record2) -> record1 -> m record2 Source #

The lifted version of belongsToJust

insert :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Key record) Source #

The lifted version of insert

insert_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m () Source #

The lifted version of insert_

insertMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m [Key record] Source #

The lifted version of insertMany

insertMany_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m () Source #

The lifted version of insertMany_

insertEntityMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Entity record] -> m () Source #

The lifted version of insertEntityMany

insertKey :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m () Source #

The lifted version of insertKey

repsert :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m () Source #

The lifted version of repsert

repsertMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [(Key record, record)] -> m () Source #

The lifted version of repsertMany

replace :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m () Source #

The lifted version of replace

delete :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m () Source #

The lifted version of delete

update :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m () Source #

The lifted version of update

updateGet :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m record Source #

The lifted version of updateGet

insertEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Entity record) Source #

The lifted version of insertEntity

insertRecord :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m record Source #

The lifted version of insertRecord

getBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m (Maybe (Entity record)) Source #

The lifted version of getBy

getByValue :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record)) Source #

The lifted version of getByValue

checkUnique :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Unique record)) Source #

The lifted version of checkUnique

checkUniqueUpdateable :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Entity record -> m (Maybe (Unique record)) Source #

The lifted version of checkUniqueUpdateable

deleteBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m () Source #

The lifted version of deleteBy

insertUnique :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Key record)) Source #

The lifted version of insertUnique

upsert :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> [Update record] -> m (Entity record) Source #

The lifted version of upsert

upsertBy :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => Unique record -> record -> [Update record] -> m (Entity record) Source #

The lifted version of upsertBy

putMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m () Source #

The lifted version of putMany

insertBy :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Either (Entity record) (Key record)) Source #

The lifted version of insertBy

insertUniqueEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record)) Source #

The lifted version of insertUniqueEntity

replaceUnique :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record, Typeable record, MonadSqlQuery m) => Key record -> record -> m (Maybe (Unique record)) Source #

The lifted version of replaceUnique

onlyUnique :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Unique record) Source #

The lifted version of onlyUnique

selectSourceRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Entity record) m2 ())) Source #

The lifted version of selectSourceRes

selectFirst :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record)) Source #

The lifted version of selectFirst

selectKeysRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Key record) m2 ())) Source #

The lifted version of selectKeysRes

count :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int Source #

The lifted version of count

exists :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Bool Source #

The lifted version of exists

selectSource :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m () Source #

The lifted version of selectSource

selectKeys :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m () Source #

The lifted version of selectKeys

selectList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Entity record] Source #

The lifted version of selectList

selectKeysList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Key record] Source #

The lifted version of selectKeysList

updateWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m () Source #

The lifted version of updateWhere

deleteWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m () Source #

The lifted version of deleteWhere

deleteWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int64 Source #

The lifted version of deleteWhereCount

updateWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m Int64 Source #

The lifted version of updateWhereCount

parseMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m (Either [Text] CautiousMigration) Source #

The lifted version of parseMigration

parseMigration' :: (HasCallStack, MonadSqlQuery m) => Migration -> m CautiousMigration Source #

The lifted version of parseMigration'

printMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m () Source #

The lifted version of printMigration

showMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text] Source #

The lifted version of showMigration

getMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Sql] Source #

The lifted version of getMigration

runMigration :: MonadSqlQuery m => Migration -> m () Source #

The lifted version of runMigration

runMigrationQuiet :: MonadSqlQuery m => Migration -> m [Text] Source #

The lifted version of runMigrationQuiet

runMigrationSilent :: MonadSqlQuery m => Migration -> m [Text] Source #

The lifted version of runMigrationSilent

runMigrationUnsafe :: MonadSqlQuery m => Migration -> m () Source #

The lifted version of runMigrationUnsafe

runMigrationUnsafeQuiet :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text] Source #

The lifted version of runMigrationUnsafeQuiet

getFieldName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => EntityField record typ -> m Text Source #

The lifted version of getFieldName

getTableName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m Text Source #

The lifted version of getTableName

withRawQuery :: MonadSqlQuery m => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> m a Source #

The lifted version of withRawQuery

rawQueryRes :: (MonadIO m2, MonadSqlQuery m) => Text -> [PersistValue] -> m (Acquire (ConduitM () [PersistValue] m2 ())) Source #

The lifted version of rawQueryRes

rawQuery :: (MonadResource m, MonadSqlQuery m) => Text -> [PersistValue] -> ConduitM () [PersistValue] m () Source #

The lifted version of rawQuery

rawExecute :: MonadSqlQuery m => Text -> [PersistValue] -> m () Source #

The lifted version of rawExecute

rawExecuteCount :: MonadSqlQuery m => Text -> [PersistValue] -> m Int64 Source #

The lifted version of rawExecuteCount

rawSql :: (RawSql a, MonadSqlQuery m) => Text -> [PersistValue] -> m [a] Source #

The lifted version of rawSql

transactionSave :: MonadSqlQuery m => m () Source #

The lifted version of transactionSave

transactionSaveWithIsolation :: MonadSqlQuery m => IsolationLevel -> m () Source #

The lifted version of transactionSaveWithIsolation

transactionUndo :: MonadSqlQuery m => m () Source #

The lifted version of transactionUndo

transactionUndoWithIsolation :: MonadSqlQuery m => IsolationLevel -> m () Source #

The lifted version of transactionUndoWithIsolation

unsafeLiftSql :: MonadSqlQuery m => Text -> (forall m2. MonadIO m2 => SqlPersistT m2 a) -> m a Source #

Lift an arbitrary SqlPersistT action into MonadSqlQuery.

This is unsafe because the action may be rerun. This function should primarily be used to interop with other libraries built on top of persistent.

Example usage:

-- | Run an esqueleto select.
select :: (MonadSqlQuery m, E.SqlSelect a r) => E.SqlQuery a -> m [r]
select q = unsafeLiftSql "esqueleto-select" (E.select q)