| Safe Haskell | None |
|---|
Database.Persist.Types
- data Checkmark
- data IsNullable
- data WhyNullable
- data EntityDef = EntityDef {
- entityHaskell :: !HaskellName
- entityDB :: !DBName
- entityID :: !DBName
- entityAttrs :: ![Attr]
- entityFields :: ![FieldDef]
- entityPrimary :: Maybe PrimaryDef
- entityUniques :: ![UniqueDef]
- entityForeigns :: ![ForeignDef]
- entityDerives :: ![Text]
- entityExtra :: !(Map Text [ExtraLine])
- entitySum :: !Bool
- type ExtraLine = [Text]
- newtype HaskellName = HaskellName {}
- newtype DBName = DBName {}
- type Attr = Text
- data FieldType
- data FieldDef = FieldDef {
- fieldHaskell :: !HaskellName
- fieldDB :: !DBName
- fieldType :: !FieldType
- fieldSqlType :: !SqlType
- fieldAttrs :: ![Attr]
- fieldStrict :: !Bool
- fieldReference :: !ReferenceDef
- data ReferenceDef
- data EmbedEntityDef = EmbedEntityDef {}
- data EmbedFieldDef = EmbedFieldDef {}
- toEmbedEntityDef :: EntityDef -> EmbedEntityDef
- toEmbedFieldDef :: FieldDef -> EmbedFieldDef
- data UniqueDef = UniqueDef {
- uniqueHaskell :: !HaskellName
- uniqueDBName :: !DBName
- uniqueFields :: ![(HaskellName, DBName)]
- uniqueAttrs :: ![Attr]
- data PrimaryDef = PrimaryDef {
- primaryFields :: ![FieldDef]
- primaryAttrs :: ![Attr]
- type ForeignFieldDef = (HaskellName, DBName)
- data ForeignDef = ForeignDef {}
- data PersistException
- data PersistValue
- = 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
- | PersistDbSpecific ByteString
- fromPersistValueText :: PersistValue -> Either Text Text
- data SqlType
- data PersistFilter
- data UpdateException
- data OnlyUniqueException = OnlyUniqueException String
- data PersistUpdate
- data SomePersistField = forall a . PersistField a => SomePersistField a
- data Update record
- = forall typ . PersistField typ => Update {
- updateField :: EntityField record typ
- updateValue :: typ
- updateUpdate :: PersistUpdate
- | BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record)
- = forall typ . PersistField typ => Update {
- data SelectOpt record
- = forall typ . Asc (EntityField record typ)
- | forall typ . Desc (EntityField record typ)
- | OffsetBy Int
- | LimitTo Int
- type family BackendSpecificFilter backend record
- data Filter record
- = forall typ . PersistField typ => Filter {
- filterField :: EntityField record typ
- filterValue :: Either typ [typ]
- filterFilter :: PersistFilter
- | FilterAnd [Filter record]
- | FilterOr [Filter record]
- | BackendFilter (BackendSpecificFilter (PersistEntityBackend record) record)
- = forall typ . PersistField typ => Filter {
- data PersistEntity record => Entity record = Entity {}
Documentation
A Checkmark should be used as a field type whenever a
uniqueness constraint should guarantee that a certain kind of
record may appear at most once, but other kinds of records may
appear any number of times.
NOTE: You need to mark any Checkmark fields as nullable
(see the following example).
For example, suppose there's a Location entity that
represents where a user has lived:
Location
user UserId
name Text
current Checkmark nullable
UniqueLocation user current
The UniqueLocation constraint allows any number of
Inactive Locations to be current. However, there may be
at most one current Location per user (i.e., either zero
or one per user).
This data type works because of the way that SQL treats
NULLable fields within uniqueness constraints. The SQL
standard says that NULL values should be considered
different, so we represent Inactive as SQL NULL, thus
allowing any number of Inactive records. On the other hand,
we represent Active as TRUE, so the uniqueness constraint
will disallow more than one Active record.
Note: There may be DBMSs that do not respect the SQL
standard's treatment of NULL values on uniqueness
constraints, please check if this data type works before
relying on it.
The SQL BOOLEAN type is used because it's the smallest data
type available. Note that we never use FALSE, just TRUE
and NULL. Provides the same behavior Maybe () would if
() was a valid PersistField.
data WhyNullable Source
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
Constructors
| EntityDef | |
Fields
| |
Constructors
| FieldDef | |
Fields
| |
data ReferenceDef Source
Constructors
| ForeignRef !HaskellName | |
| EmbedRef EmbedEntityDef | |
| NoReference |
Instances
data EmbedEntityDef Source
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 | |
data EmbedFieldDef Source
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 | |
Constructors
| UniqueDef | |
Fields
| |
data PrimaryDef Source
Constructors
| PrimaryDef | |
Fields
| |
Instances
type ForeignFieldDef = (HaskellName, DBName)Source
Used instead of FieldDef to generate a smaller amount of code
data PersistException Source
Constructors
| PersistError Text | Generic Exception |
| PersistMarshalError Text | |
| PersistInvalidField Text | |
| PersistForeignConstraintUnmet Text | |
| PersistMongoDBError Text | |
| PersistMongoDBUnsupported Text |
data PersistValue Source
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 |
| PersistDbSpecific ByteString | Using data Geo = Geo ByteString instance PersistField Geo where toPersistValue (Geo t) = PersistDbSpecific t fromPersistValue (PersistDbSpecific t) = Right $ Geo $ Data.ByteString.concat [', t, '] fromPersistValue _ = Left Geo values must be converted from PersistDbSpecific instance PersistFieldSql Geo where sqlType _ = SqlOther GEOGRAPHY(POINT,4326) toPoint :: Double -> Double -> Geo toPoint lat lon = Geo $ Data.ByteString.concat ['POINT(, ps $ lon, , ps $ lat, )'] where ps = Data.Text.pack . show If Foo has a geography field, we can then perform insertions like the following: insert $ Foo (toPoint 44 44) |
A SQL data type. Naming attempts to reflect the underlying Haskell datatypes, eg SqlString instead of SqlVarchar. Different SQL databases may have different translations for these types.
data PersistFilter Source
Instances
data UpdateException Source
Constructors
| KeyNotFound String | |
| UpsertError String |
data OnlyUniqueException Source
Constructors
| OnlyUniqueException String |
data PersistUpdate Source
updataing a database entity
Persistent users use combinators to create these
Constructors
| forall typ . PersistField typ => Update | |
Fields
| |
| BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record) | |
query options
Persistent users use these directly
Constructors
| forall typ . Asc (EntityField record typ) | |
| forall typ . Desc (EntityField record typ) | |
| OffsetBy Int | |
| LimitTo Int |
type family BackendSpecificFilter backend record Source
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
Constructors
| forall typ . PersistField typ => Filter | |
Fields
| |
| FilterAnd [Filter record] | convenient for internal use, not needed for the API |
| FilterOr [Filter record] | |
| BackendFilter (BackendSpecificFilter (PersistEntityBackend record) record) | |
data PersistEntity record => Entity record Source
Datatype that represents an entity, with both its Key and
its Haskell record representation.
When using a SQL-based backend (such as SQLite or
PostgreSQL), an Entity may take any number of columns
depending on how many fields it has. In order to reconstruct
your entity on the Haskell side, persistent needs all of
your entity columns and in the right order. Note that you
don't need to worry about this when using persistent's API
since everything is handled correctly behind the scenes.
However, if you want to issue a raw SQL command that returns
an Entity, then you have to be careful with the column
order. While you could use SELECT Entity.* WHERE ... and
that would work most of the time, there are times when the
order of the columns on your database is different from the
order that persistent expects (for example, if you add a new
field in the middle of you entity definition and then use the
migration code -- persistent will expect the column to be in
the middle, but your DBMS will put it as the last column).
So, instead of using a query like the one above, you may use
rawSql (from the
Database.Persist.GenericSql module) with its /entity
selection placeholder/ (a double question mark ??). Using
rawSql the query above must be written as SELECT ?? WHERE
... Then rawSql will replace ?? with the list of all
columns that we need from your entity in the right order. If
your query returns two entities (i.e. (Entity backend a,
Entity backend b)), then you must you use SELECT ??, ??
WHERE ..., and so on.
Instances
| (PersistEntity record, Eq (Key record), Eq record) => Eq (Entity record) | |
| (PersistEntity record, Ord (Key record), Ord record) => Ord (Entity record) | |
| (PersistEntity record, Read (Key record), Read record) => Read (Entity record) | |
| (PersistEntity record, Show (Key record), Show record) => Show (Entity record) | |
| (PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record) | |
| (PersistField record, PersistEntity record) => PersistFieldSql (Entity record) | |
| (PersistEntity a, ~ * (PersistEntityBackend a) SqlBackend) => RawSql (Entity a) |