persistent-2.14.6.3: Type-safe, multi-backend data serialization.

Safe Haskell | None
Language | Haskell2010

Database.Persist.Types

Contents

- Various Types of Names
- Database Definitions
  - Entity/Table Definitions
  - Field definitions
- Intermediate Values
- Other Useful Stuff
- The rest of the types

Description

This module exports many types and functions for operating on `persistent`'s database representation. It's a bit of a kitchen sink. In the future, this module will be reorganized, and many of the dependent modules will be viewable on their own for easier documentation and organization.

Synopsis

- module Database.Persist.Names
- module Database.Persist.EntityDef
- module Database.Persist.FieldDef
- module Database.Persist.PersistValue
- data Update record
  - = PersistField typ => Update {
    - updateField :: EntityField record typ
    - updateValue :: typ
    - updateUpdate :: PersistUpdate
    }
  - | BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record)
- type family BackendSpecificUpdate backend record
- data SelectOpt record
  - = Asc (EntityField record typ)
  - | Desc (EntityField record typ)
  - | OffsetBy Int
  - | LimitTo Int
- 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
- type family BackendSpecificFilter backend record
- data family Key record
- data Entity record = Entity {
  - entityKey :: Key record
  - entityVal :: record
  }
- newtype OverflowNatural = OverflowNatural {
  - unOverflowNatural :: Natural
  }
- data PersistFilter
  - = Eq
  - | Ne
  - | Gt
  - | Lt
  - | Ge
  - | Le
  - | In
  - | NotIn
  - | BackendSpecificFilter 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 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 PersistLiteral :: ByteString -> PersistValue
  - pattern PersistLiteralEscaped :: ByteString -> PersistValue
  - pattern PersistDbSpecific :: ByteString -> PersistValue
- data PersistUpdate
  - = Assign
  - | Add
  - | Subtract
  - | Multiply
  - | Divide
  - | BackendSpecificUpdate Text
- type Attr = Text
- data CascadeAction
  - = Cascade
  - | Restrict
  - | SetNull
  - | SetDefault
- data Checkmark
  - = Active
  - | Inactive
- data CompositeDef = CompositeDef {
  - compositeFields :: !(NonEmpty FieldDef)
  - compositeAttrs :: ![Attr]
  }
- data EmbedEntityDef = EmbedEntityDef {
  - embeddedHaskell :: EntityNameHS
  - embeddedFields :: [EmbedFieldDef]
  }
- data EmbedFieldDef = EmbedFieldDef {
  - emFieldDB :: FieldNameDB
  - emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)
  }
- type ExtraLine = [Text]
- data FieldAttr
  - = FieldAttrMaybe
  - | FieldAttrNullable
  - | FieldAttrMigrationOnly
  - | FieldAttrSafeToRemove
  - | FieldAttrNoreference
  - | FieldAttrReference Text
  - | FieldAttrConstraint Text
  - | FieldAttrDefault Text
  - | FieldAttrSqltype Text
  - | FieldAttrMaxlen Integer
  - | FieldAttrSql Text
  - | FieldAttrOther Text
- data FieldCascade = FieldCascade {
  - fcOnUpdate :: !(Maybe CascadeAction)
  - fcOnDelete :: !(Maybe CascadeAction)
  }
- data FieldType
  - = FTTypeCon (Maybe Text) Text
  - | FTLit FieldTypeLit
  - | FTTypePromoted Text
  - | FTApp FieldType FieldType
  - | FTList FieldType
- data ForeignDef = ForeignDef {
  - foreignRefTableHaskell :: !EntityNameHS
  - foreignRefTableDBName :: !EntityNameDB
  - foreignConstraintNameHaskell :: !ConstraintNameHS
  - foreignConstraintNameDBName :: !ConstraintNameDB
  - foreignFieldCascade :: !FieldCascade
  - foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)]
  - foreignAttrs :: ![Attr]
  - foreignNullable :: Bool
  - foreignToPrimary :: Bool
  }
- type ForeignFieldDef = (FieldNameHS, FieldNameDB)
- data IsNullable
  - = Nullable !WhyNullable
  - | NotNullable
- data LiteralType
  - = Escaped
  - | Unescaped
  - | DbSpecific
- data PersistException
  - = PersistError Text
  - | PersistMarshalError Text
  - | PersistInvalidField Text
  - | PersistForeignConstraintUnmet Text
  - | PersistMongoDBError Text
  - | PersistMongoDBUnsupported Text
- data ReferenceDef
  - = NoReference
  - | ForeignRef !EntityNameHS
  - | EmbedRef EntityNameHS
  - | SelfReference
- data SqlType
  - = SqlString
  - | SqlInt32
  - | SqlInt64
  - | SqlReal
  - | SqlNumeric Word32 Word32
  - | SqlBool
  - | SqlDay
  - | SqlTime
  - | SqlDayTime
  - | SqlBlob
  - | SqlOther Text
- data UniqueDef = UniqueDef {
  - uniqueHaskell :: !ConstraintNameHS
  - uniqueDBName :: !ConstraintNameDB
  - uniqueFields :: !(NonEmpty (FieldNameHS, FieldNameDB))
  - uniqueAttrs :: ![Attr]
  }
- data UpdateException
  - = KeyNotFound String
  - | UpsertError String
- data WhyNullable
  - = ByMaybeAttr
  - | ByNullableAttr
- fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable
- keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
- noCascade :: FieldCascade
- parseFieldAttrs :: [Text] -> [FieldAttr]

# Various Types of Names

There are so many kinds of names. `persistent` defines newtype wrappers for `Text` so you don't confuse what a name is and what it is supposed to be used for

module Database.Persist.Names

# Database Definitions

## Entity/Table Definitions

The `EntityDef` type is used by `persistent` to generate Haskell code, generate database migrations, and maintain metadata about entities. These are generated in the call to `mkPersist`.

module Database.Persist.EntityDef

## Field definitions

The `FieldDef` type is used to describe how a field should be represented at the Haskell and database layers.

module Database.Persist.FieldDef

# Intermediate Values

The `PersistValue` type is used as an intermediate layer between database and Haskell types.

module Database.Persist.PersistValue

# Other Useful Stuff

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) |

type family BackendSpecificUpdate backend record #

data SelectOpt record #

Query options.

Persistent users use these directly.

Constructors

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

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: 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 |

type family BackendSpecificFilter backend record #

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) #

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) |
Instance details Defined in Database.Persist.Class.PersistEntity type Rep (Entity record) = D1 ('MetaData "Entity" "Database.Persist.Class.PersistEntity" "persistent-2.14.6.3-JVVGzpBhz0IC64DMc3fyym" '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)))
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.3-JVVGzpBhz0IC64DMc3fyym" '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)))

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: 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: 2.11.0
Instance details Defined in Database.Persist.Sql.Class Methods sqlType :: Proxy OverflowNatural -> SqlType #

# The rest of the types

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 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: 2.11.0 fieldComments :: !(Maybe Text) Optional comments for a `Field`. Since: 2.10.0 fieldGenerated :: !(Maybe Text) Whether or not the field is a `GENERATED` column, and additionally the expression to use for generation. Since: 2.11.0.0 fieldIsImplicitIdColumn :: !Bool `True` if the field is an implicit ID column. `False` otherwise. Since: 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 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: 2.12.0.0

Bundled Patterns

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: 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: 2.12.0.0
pattern PersistDbSpecific :: ByteString -> PersistValue | Deprecated: Deprecated since 2.11 because of inconsistent escaping behavior across backends. The Postgres backend escapes these values, while the MySQL backend does not. If you are using this, please switch to `PersistLiteral_` and provide a relevant `LiteralType` for your conversion. 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: 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] # omittedField :: Maybe PersistValue #
ToJSON PersistValue # |
Instance details Defined in Database.Persist.PersistValue Methods toJSON :: PersistValue -> Value # toEncoding :: PersistValue -> Encoding # toJSONList :: [PersistValue] -> Value # toEncodingList :: [PersistValue] -> Encoding # omitField :: PersistValue -> Bool #
NFData PersistValue # | Since: 2.14.4.0
Instance details Defined in Database.Persist.PersistValue Methods rnf :: PersistValue -> () #
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 #
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 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 #

type Attr = Text #

data CascadeAction #

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

Since: 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 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` `Location`s 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 `NULL`able 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 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 #

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 #

type ExtraLine = [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: 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 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: 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 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 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: 2.11.0 foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)] foreignAttrs :: ![Attr] foreignNullable :: Bool foreignToPrimary :: Bool Determines if the reference is towards a Primary Key or not. Since: 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 #

type ForeignFieldDef = (FieldNameHS, FieldNameDB) #

Used instead of FieldDef to generate a smaller amount of code

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 LiteralType #

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

Since: 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: 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: 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: 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 #

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 # backtraceDesired :: PersistException -> Bool #
Show PersistException # |
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistException -> ShowS # show :: PersistException -> String # showList :: [PersistException] -> ShowS #

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 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 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 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 # backtraceDesired :: UpdateException -> Bool #
Show UpdateException # |
Instance details Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> UpdateException -> ShowS # show :: UpdateException -> String # showList :: [UpdateException] -> ShowS #

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 #

fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable #

keyAndEntityFields :: EntityDef -> NonEmpty FieldDef #

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

noCascade :: FieldCascade #

A `FieldCascade` that does nothing.

Since: 2.11.0

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: 2.11.0.0