{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DeriveLift #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}

module Database.Persist.Types.Base
    ( module Database.Persist.Types.Base
    -- * Re-exports
    , PersistValue(..)
    , fromPersistValueText
    , LiteralType(..)
    ) where

import Control.Exception (Exception)
import Data.Char (isSpace)
import Data.List.NonEmpty (NonEmpty(..))
import qualified Data.List.NonEmpty as NEL
import Data.Map (Map)
import Data.Maybe (isNothing)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Word (Word32)
import Language.Haskell.TH.Syntax (Lift(..))
import Web.HttpApiData
       ( FromHttpApiData(..)
       , ToHttpApiData(..)
       , parseBoundedTextData
       , showTextData
       )
import Web.PathPieces (PathPiece(..))
    -- Bring `Lift (Map k v)` instance into scope, as well as `Lift Text`
    -- instance on pre-1.2.4 versions of `text`
import Instances.TH.Lift ()

import Database.Persist.Names
import Database.Persist.PersistValue

-- | 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'.
data Checkmark = 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.
    deriving (Checkmark -> Checkmark -> Bool
(Checkmark -> Checkmark -> Bool)
-> (Checkmark -> Checkmark -> Bool) -> Eq Checkmark
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Checkmark -> Checkmark -> Bool
== :: Checkmark -> Checkmark -> Bool
$c/= :: Checkmark -> Checkmark -> Bool
/= :: Checkmark -> Checkmark -> Bool
Eq, Eq Checkmark
Eq Checkmark =>
(Checkmark -> Checkmark -> Ordering)
-> (Checkmark -> Checkmark -> Bool)
-> (Checkmark -> Checkmark -> Bool)
-> (Checkmark -> Checkmark -> Bool)
-> (Checkmark -> Checkmark -> Bool)
-> (Checkmark -> Checkmark -> Checkmark)
-> (Checkmark -> Checkmark -> Checkmark)
-> Ord Checkmark
Checkmark -> Checkmark -> Bool
Checkmark -> Checkmark -> Ordering
Checkmark -> Checkmark -> Checkmark
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Checkmark -> Checkmark -> Ordering
compare :: Checkmark -> Checkmark -> Ordering
$c< :: Checkmark -> Checkmark -> Bool
< :: Checkmark -> Checkmark -> Bool
$c<= :: Checkmark -> Checkmark -> Bool
<= :: Checkmark -> Checkmark -> Bool
$c> :: Checkmark -> Checkmark -> Bool
> :: Checkmark -> Checkmark -> Bool
$c>= :: Checkmark -> Checkmark -> Bool
>= :: Checkmark -> Checkmark -> Bool
$cmax :: Checkmark -> Checkmark -> Checkmark
max :: Checkmark -> Checkmark -> Checkmark
$cmin :: Checkmark -> Checkmark -> Checkmark
min :: Checkmark -> Checkmark -> Checkmark
Ord, ReadPrec [Checkmark]
ReadPrec Checkmark
Int -> ReadS Checkmark
ReadS [Checkmark]
(Int -> ReadS Checkmark)
-> ReadS [Checkmark]
-> ReadPrec Checkmark
-> ReadPrec [Checkmark]
-> Read Checkmark
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Checkmark
readsPrec :: Int -> ReadS Checkmark
$creadList :: ReadS [Checkmark]
readList :: ReadS [Checkmark]
$creadPrec :: ReadPrec Checkmark
readPrec :: ReadPrec Checkmark
$creadListPrec :: ReadPrec [Checkmark]
readListPrec :: ReadPrec [Checkmark]
Read, Int -> Checkmark -> ShowS
[Checkmark] -> ShowS
Checkmark -> [Char]
(Int -> Checkmark -> ShowS)
-> (Checkmark -> [Char])
-> ([Checkmark] -> ShowS)
-> Show Checkmark
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Checkmark -> ShowS
showsPrec :: Int -> Checkmark -> ShowS
$cshow :: Checkmark -> [Char]
show :: Checkmark -> [Char]
$cshowList :: [Checkmark] -> ShowS
showList :: [Checkmark] -> ShowS
Show, Int -> Checkmark
Checkmark -> Int
Checkmark -> [Checkmark]
Checkmark -> Checkmark
Checkmark -> Checkmark -> [Checkmark]
Checkmark -> Checkmark -> Checkmark -> [Checkmark]
(Checkmark -> Checkmark)
-> (Checkmark -> Checkmark)
-> (Int -> Checkmark)
-> (Checkmark -> Int)
-> (Checkmark -> [Checkmark])
-> (Checkmark -> Checkmark -> [Checkmark])
-> (Checkmark -> Checkmark -> [Checkmark])
-> (Checkmark -> Checkmark -> Checkmark -> [Checkmark])
-> Enum Checkmark
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Checkmark -> Checkmark
succ :: Checkmark -> Checkmark
$cpred :: Checkmark -> Checkmark
pred :: Checkmark -> Checkmark
$ctoEnum :: Int -> Checkmark
toEnum :: Int -> Checkmark
$cfromEnum :: Checkmark -> Int
fromEnum :: Checkmark -> Int
$cenumFrom :: Checkmark -> [Checkmark]
enumFrom :: Checkmark -> [Checkmark]
$cenumFromThen :: Checkmark -> Checkmark -> [Checkmark]
enumFromThen :: Checkmark -> Checkmark -> [Checkmark]
$cenumFromTo :: Checkmark -> Checkmark -> [Checkmark]
enumFromTo :: Checkmark -> Checkmark -> [Checkmark]
$cenumFromThenTo :: Checkmark -> Checkmark -> Checkmark -> [Checkmark]
enumFromThenTo :: Checkmark -> Checkmark -> Checkmark -> [Checkmark]
Enum, Checkmark
Checkmark -> Checkmark -> Bounded Checkmark
forall a. a -> a -> Bounded a
$cminBound :: Checkmark
minBound :: Checkmark
$cmaxBound :: Checkmark
maxBound :: Checkmark
Bounded)

instance ToHttpApiData Checkmark where
    toUrlPiece :: Checkmark -> Text
toUrlPiece = Checkmark -> Text
forall a. Show a => a -> Text
showTextData

instance FromHttpApiData Checkmark where
    parseUrlPiece :: Text -> Either Text Checkmark
parseUrlPiece = Text -> Either Text Checkmark
forall a. (Show a, Bounded a, Enum a) => Text -> Either Text a
parseBoundedTextData

instance PathPiece Checkmark where
  toPathPiece :: Checkmark -> Text
toPathPiece Checkmark
Active = Text
"active"
  toPathPiece Checkmark
Inactive = Text
"inactive"

  fromPathPiece :: Text -> Maybe Checkmark
fromPathPiece Text
"active" = Checkmark -> Maybe Checkmark
forall a. a -> Maybe a
Just Checkmark
Active
  fromPathPiece Text
"inactive" = Checkmark -> Maybe Checkmark
forall a. a -> Maybe a
Just Checkmark
Inactive
  fromPathPiece Text
_ = Maybe Checkmark
forall a. Maybe a
Nothing

data IsNullable
    = Nullable !WhyNullable
    | NotNullable
    deriving (IsNullable -> IsNullable -> Bool
(IsNullable -> IsNullable -> Bool)
-> (IsNullable -> IsNullable -> Bool) -> Eq IsNullable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IsNullable -> IsNullable -> Bool
== :: IsNullable -> IsNullable -> Bool
$c/= :: IsNullable -> IsNullable -> Bool
/= :: IsNullable -> IsNullable -> Bool
Eq, Int -> IsNullable -> ShowS
[IsNullable] -> ShowS
IsNullable -> [Char]
(Int -> IsNullable -> ShowS)
-> (IsNullable -> [Char])
-> ([IsNullable] -> ShowS)
-> Show IsNullable
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IsNullable -> ShowS
showsPrec :: Int -> IsNullable -> ShowS
$cshow :: IsNullable -> [Char]
show :: IsNullable -> [Char]
$cshowList :: [IsNullable] -> ShowS
showList :: [IsNullable] -> ShowS
Show)

fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable
fieldAttrsContainsNullable [FieldAttr]
s
    | FieldAttr
FieldAttrMaybe    FieldAttr -> [FieldAttr] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FieldAttr]
s = WhyNullable -> IsNullable
Nullable WhyNullable
ByMaybeAttr
    | FieldAttr
FieldAttrNullable FieldAttr -> [FieldAttr] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FieldAttr]
s = WhyNullable -> IsNullable
Nullable WhyNullable
ByNullableAttr
    | Bool
otherwise = IsNullable
NotNullable

-- | The reason why a field is 'nullable' is very important.  A
-- field that is nullable because of a @Maybe@ tag will have its
-- type changed from @A@ to @Maybe A@.  OTOH, a field that is
-- nullable because of a @nullable@ tag will remain with the same
-- type.
data WhyNullable = ByMaybeAttr
                 | ByNullableAttr
                  deriving (WhyNullable -> WhyNullable -> Bool
(WhyNullable -> WhyNullable -> Bool)
-> (WhyNullable -> WhyNullable -> Bool) -> Eq WhyNullable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhyNullable -> WhyNullable -> Bool
== :: WhyNullable -> WhyNullable -> Bool
$c/= :: WhyNullable -> WhyNullable -> Bool
/= :: WhyNullable -> WhyNullable -> Bool
Eq, Int -> WhyNullable -> ShowS
[WhyNullable] -> ShowS
WhyNullable -> [Char]
(Int -> WhyNullable -> ShowS)
-> (WhyNullable -> [Char])
-> ([WhyNullable] -> ShowS)
-> Show WhyNullable
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhyNullable -> ShowS
showsPrec :: Int -> WhyNullable -> ShowS
$cshow :: WhyNullable -> [Char]
show :: WhyNullable -> [Char]
$cshowList :: [WhyNullable] -> ShowS
showList :: [WhyNullable] -> ShowS
Show)

-- | 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.
data EntityDef = EntityDef
    { EntityDef -> EntityNameHS
entityHaskell :: !EntityNameHS
    -- ^ The name of the entity as Haskell understands it.
    , EntityDef -> EntityNameDB
entityDB      :: !EntityNameDB
    -- ^ The name of the database table corresponding to the entity.
    , EntityDef -> EntityIdDef
entityId      :: !EntityIdDef
    -- ^ The entity's primary key or identifier.
    , EntityDef -> [Text]
entityAttrs   :: ![Attr]
    -- ^ The @persistent@ entity syntax allows you to add arbitrary 'Attr's
    -- to an entity using the @!@ operator. Those attributes are stored in
    -- this list.
    , EntityDef -> [FieldDef]
entityFields  :: ![FieldDef]
    -- ^ The fields for this entity. Note that the ID field will not be
    -- present in this list. To get all of the fields for an entity, use
    -- 'keyAndEntityFields'.
    , EntityDef -> [UniqueDef]
entityUniques :: ![UniqueDef]
    -- ^ The Uniqueness constraints for this entity.
    , EntityDef -> [ForeignDef]
entityForeigns:: ![ForeignDef]
    -- ^ The foreign key relationships that this entity has to other
    -- entities.
    , EntityDef -> [Text]
entityDerives :: ![Text]
    -- ^ A list of type classes that have been derived for this entity.
    , EntityDef -> Map Text [[Text]]
entityExtra   :: !(Map Text [ExtraLine])
    , EntityDef -> Bool
entitySum     :: !Bool
    -- ^ Whether or not this entity represents a sum type in the database.
    , EntityDef -> Maybe Text
entityComments :: !(Maybe Text)
    -- ^ Optional comments on the entity.
    --
    -- @since 2.10.0
    }
    deriving (Int -> EntityDef -> ShowS
[EntityDef] -> ShowS
EntityDef -> [Char]
(Int -> EntityDef -> ShowS)
-> (EntityDef -> [Char])
-> ([EntityDef] -> ShowS)
-> Show EntityDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EntityDef -> ShowS
showsPrec :: Int -> EntityDef -> ShowS
$cshow :: EntityDef -> [Char]
show :: EntityDef -> [Char]
$cshowList :: [EntityDef] -> ShowS
showList :: [EntityDef] -> ShowS
Show, EntityDef -> EntityDef -> Bool
(EntityDef -> EntityDef -> Bool)
-> (EntityDef -> EntityDef -> Bool) -> Eq EntityDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EntityDef -> EntityDef -> Bool
== :: EntityDef -> EntityDef -> Bool
$c/= :: EntityDef -> EntityDef -> Bool
/= :: EntityDef -> EntityDef -> Bool
Eq, ReadPrec [EntityDef]
ReadPrec EntityDef
Int -> ReadS EntityDef
ReadS [EntityDef]
(Int -> ReadS EntityDef)
-> ReadS [EntityDef]
-> ReadPrec EntityDef
-> ReadPrec [EntityDef]
-> Read EntityDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EntityDef
readsPrec :: Int -> ReadS EntityDef
$creadList :: ReadS [EntityDef]
readList :: ReadS [EntityDef]
$creadPrec :: ReadPrec EntityDef
readPrec :: ReadPrec EntityDef
$creadListPrec :: ReadPrec [EntityDef]
readListPrec :: ReadPrec [EntityDef]
Read, Eq EntityDef
Eq EntityDef =>
(EntityDef -> EntityDef -> Ordering)
-> (EntityDef -> EntityDef -> Bool)
-> (EntityDef -> EntityDef -> Bool)
-> (EntityDef -> EntityDef -> Bool)
-> (EntityDef -> EntityDef -> Bool)
-> (EntityDef -> EntityDef -> EntityDef)
-> (EntityDef -> EntityDef -> EntityDef)
-> Ord EntityDef
EntityDef -> EntityDef -> Bool
EntityDef -> EntityDef -> Ordering
EntityDef -> EntityDef -> EntityDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EntityDef -> EntityDef -> Ordering
compare :: EntityDef -> EntityDef -> Ordering
$c< :: EntityDef -> EntityDef -> Bool
< :: EntityDef -> EntityDef -> Bool
$c<= :: EntityDef -> EntityDef -> Bool
<= :: EntityDef -> EntityDef -> Bool
$c> :: EntityDef -> EntityDef -> Bool
> :: EntityDef -> EntityDef -> Bool
$c>= :: EntityDef -> EntityDef -> Bool
>= :: EntityDef -> EntityDef -> Bool
$cmax :: EntityDef -> EntityDef -> EntityDef
max :: EntityDef -> EntityDef -> EntityDef
$cmin :: EntityDef -> EntityDef -> EntityDef
min :: EntityDef -> EntityDef -> EntityDef
Ord, (forall (m :: * -> *). Quote m => EntityDef -> m Exp)
-> (forall (m :: * -> *). Quote m => EntityDef -> Code m EntityDef)
-> Lift EntityDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EntityDef -> m Exp
forall (m :: * -> *). Quote m => EntityDef -> Code m EntityDef
$clift :: forall (m :: * -> *). Quote m => EntityDef -> m Exp
lift :: forall (m :: * -> *). Quote m => EntityDef -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => EntityDef -> Code m EntityDef
liftTyped :: forall (m :: * -> *). Quote m => EntityDef -> Code m EntityDef
Lift)

-- | The definition for the entity's primary key ID.
--
-- @since 2.13.0.0
data EntityIdDef
    = 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 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 2.13.0.0
    deriving (Int -> EntityIdDef -> ShowS
[EntityIdDef] -> ShowS
EntityIdDef -> [Char]
(Int -> EntityIdDef -> ShowS)
-> (EntityIdDef -> [Char])
-> ([EntityIdDef] -> ShowS)
-> Show EntityIdDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EntityIdDef -> ShowS
showsPrec :: Int -> EntityIdDef -> ShowS
$cshow :: EntityIdDef -> [Char]
show :: EntityIdDef -> [Char]
$cshowList :: [EntityIdDef] -> ShowS
showList :: [EntityIdDef] -> ShowS
Show, EntityIdDef -> EntityIdDef -> Bool
(EntityIdDef -> EntityIdDef -> Bool)
-> (EntityIdDef -> EntityIdDef -> Bool) -> Eq EntityIdDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EntityIdDef -> EntityIdDef -> Bool
== :: EntityIdDef -> EntityIdDef -> Bool
$c/= :: EntityIdDef -> EntityIdDef -> Bool
/= :: EntityIdDef -> EntityIdDef -> Bool
Eq, ReadPrec [EntityIdDef]
ReadPrec EntityIdDef
Int -> ReadS EntityIdDef
ReadS [EntityIdDef]
(Int -> ReadS EntityIdDef)
-> ReadS [EntityIdDef]
-> ReadPrec EntityIdDef
-> ReadPrec [EntityIdDef]
-> Read EntityIdDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EntityIdDef
readsPrec :: Int -> ReadS EntityIdDef
$creadList :: ReadS [EntityIdDef]
readList :: ReadS [EntityIdDef]
$creadPrec :: ReadPrec EntityIdDef
readPrec :: ReadPrec EntityIdDef
$creadListPrec :: ReadPrec [EntityIdDef]
readListPrec :: ReadPrec [EntityIdDef]
Read, Eq EntityIdDef
Eq EntityIdDef =>
(EntityIdDef -> EntityIdDef -> Ordering)
-> (EntityIdDef -> EntityIdDef -> Bool)
-> (EntityIdDef -> EntityIdDef -> Bool)
-> (EntityIdDef -> EntityIdDef -> Bool)
-> (EntityIdDef -> EntityIdDef -> Bool)
-> (EntityIdDef -> EntityIdDef -> EntityIdDef)
-> (EntityIdDef -> EntityIdDef -> EntityIdDef)
-> Ord EntityIdDef
EntityIdDef -> EntityIdDef -> Bool
EntityIdDef -> EntityIdDef -> Ordering
EntityIdDef -> EntityIdDef -> EntityIdDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EntityIdDef -> EntityIdDef -> Ordering
compare :: EntityIdDef -> EntityIdDef -> Ordering
$c< :: EntityIdDef -> EntityIdDef -> Bool
< :: EntityIdDef -> EntityIdDef -> Bool
$c<= :: EntityIdDef -> EntityIdDef -> Bool
<= :: EntityIdDef -> EntityIdDef -> Bool
$c> :: EntityIdDef -> EntityIdDef -> Bool
> :: EntityIdDef -> EntityIdDef -> Bool
$c>= :: EntityIdDef -> EntityIdDef -> Bool
>= :: EntityIdDef -> EntityIdDef -> Bool
$cmax :: EntityIdDef -> EntityIdDef -> EntityIdDef
max :: EntityIdDef -> EntityIdDef -> EntityIdDef
$cmin :: EntityIdDef -> EntityIdDef -> EntityIdDef
min :: EntityIdDef -> EntityIdDef -> EntityIdDef
Ord, (forall (m :: * -> *). Quote m => EntityIdDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    EntityIdDef -> Code m EntityIdDef)
-> Lift EntityIdDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EntityIdDef -> m Exp
forall (m :: * -> *). Quote m => EntityIdDef -> Code m EntityIdDef
$clift :: forall (m :: * -> *). Quote m => EntityIdDef -> m Exp
lift :: forall (m :: * -> *). Quote m => EntityIdDef -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => EntityIdDef -> Code m EntityIdDef
liftTyped :: forall (m :: * -> *). Quote m => EntityIdDef -> Code m EntityIdDef
Lift)

-- | Return the @['FieldDef']@ for the entity keys.
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
entitiesPrimary EntityDef
t =
    case EntityDef -> EntityIdDef
entityId EntityDef
t of
        EntityIdNaturalKey CompositeDef
fds ->
            CompositeDef -> NonEmpty FieldDef
compositeFields CompositeDef
fds
        EntityIdField FieldDef
fd ->
            FieldDef -> NonEmpty FieldDef
forall a. a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FieldDef
fd

entityPrimary :: EntityDef -> Maybe CompositeDef
entityPrimary :: EntityDef -> Maybe CompositeDef
entityPrimary EntityDef
t =
    case EntityDef -> EntityIdDef
entityId EntityDef
t of
        EntityIdNaturalKey CompositeDef
c ->
            CompositeDef -> Maybe CompositeDef
forall a. a -> Maybe a
Just CompositeDef
c
        EntityIdDef
_ ->
            Maybe CompositeDef
forall a. Maybe a
Nothing

entityKeyFields :: EntityDef -> NonEmpty FieldDef
entityKeyFields :: EntityDef -> NonEmpty FieldDef
entityKeyFields =
    EntityDef -> NonEmpty FieldDef
entitiesPrimary

-- | Returns a 'NonEmpty' list of 'FieldDef' that correspond with the key
-- columns for an 'EntityDef'.
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
keyAndEntityFields EntityDef
ent =
    EntityIdDef -> [FieldDef] -> NonEmpty FieldDef
keyWithFields (EntityDef -> EntityIdDef
entityId EntityDef
ent) [FieldDef]
fields
  where
    fields :: [FieldDef]
fields = (FieldDef -> Bool) -> [FieldDef] -> [FieldDef]
forall a. (a -> Bool) -> [a] -> [a]
filter FieldDef -> Bool
isHaskellField ([FieldDef] -> [FieldDef]) -> [FieldDef] -> [FieldDef]
forall a b. (a -> b) -> a -> b
$ EntityDef -> [FieldDef]
entityFields EntityDef
ent

-- | Returns a 'NonEmpty' list of 'FieldDef' that correspond with the key
-- columns for an '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 fields on the Haskell type use 'keyAndEntityFieldsDatabase'
--
-- @since 2.14.6.0
keyAndEntityFieldsDatabase :: EntityDef -> NonEmpty FieldDef
keyAndEntityFieldsDatabase :: EntityDef -> NonEmpty FieldDef
keyAndEntityFieldsDatabase EntityDef
ent =
    EntityIdDef -> [FieldDef] -> NonEmpty FieldDef
keyWithFields (EntityDef -> EntityIdDef
entityId EntityDef
ent) [FieldDef]
fields
  where
    fields :: [FieldDef]
fields = EntityDef -> [FieldDef]
entityFields EntityDef
ent

keyWithFields :: EntityIdDef -> [FieldDef] -> NonEmpty FieldDef
keyWithFields :: EntityIdDef -> [FieldDef] -> NonEmpty FieldDef
keyWithFields EntityIdDef
entId [FieldDef]
fields =
    case EntityIdDef
entId of
        EntityIdField FieldDef
fd ->
            FieldDef
fd FieldDef -> [FieldDef] -> NonEmpty FieldDef
forall a. a -> [a] -> NonEmpty a
:| [FieldDef]
fields
        EntityIdNaturalKey CompositeDef
_ ->
            case [FieldDef] -> Maybe (NonEmpty FieldDef)
forall a. [a] -> Maybe (NonEmpty a)
NEL.nonEmpty [FieldDef]
fields of
                Maybe (NonEmpty FieldDef)
Nothing ->
                    [Char] -> NonEmpty FieldDef
forall a. HasCallStack => [Char] -> a
error ([Char] -> NonEmpty FieldDef) -> [Char] -> NonEmpty FieldDef
forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
forall a. Monoid a => [a] -> a
mconcat
                        [ [Char]
"persistent internal guarantee failed: entity is "
                        , [Char]
"defined with an entityId = EntityIdNaturalKey, "
                        , [Char]
"but somehow doesn't have any entity fields."
                        ]
                Just NonEmpty FieldDef
xs ->
                    NonEmpty FieldDef
xs

type ExtraLine = [Text]

type Attr = Text

-- | 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
data FieldAttr
    = 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.
    deriving (Int -> FieldAttr -> ShowS
[FieldAttr] -> ShowS
FieldAttr -> [Char]
(Int -> FieldAttr -> ShowS)
-> (FieldAttr -> [Char])
-> ([FieldAttr] -> ShowS)
-> Show FieldAttr
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldAttr -> ShowS
showsPrec :: Int -> FieldAttr -> ShowS
$cshow :: FieldAttr -> [Char]
show :: FieldAttr -> [Char]
$cshowList :: [FieldAttr] -> ShowS
showList :: [FieldAttr] -> ShowS
Show, FieldAttr -> FieldAttr -> Bool
(FieldAttr -> FieldAttr -> Bool)
-> (FieldAttr -> FieldAttr -> Bool) -> Eq FieldAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldAttr -> FieldAttr -> Bool
== :: FieldAttr -> FieldAttr -> Bool
$c/= :: FieldAttr -> FieldAttr -> Bool
/= :: FieldAttr -> FieldAttr -> Bool
Eq, ReadPrec [FieldAttr]
ReadPrec FieldAttr
Int -> ReadS FieldAttr
ReadS [FieldAttr]
(Int -> ReadS FieldAttr)
-> ReadS [FieldAttr]
-> ReadPrec FieldAttr
-> ReadPrec [FieldAttr]
-> Read FieldAttr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldAttr
readsPrec :: Int -> ReadS FieldAttr
$creadList :: ReadS [FieldAttr]
readList :: ReadS [FieldAttr]
$creadPrec :: ReadPrec FieldAttr
readPrec :: ReadPrec FieldAttr
$creadListPrec :: ReadPrec [FieldAttr]
readListPrec :: ReadPrec [FieldAttr]
Read, Eq FieldAttr
Eq FieldAttr =>
(FieldAttr -> FieldAttr -> Ordering)
-> (FieldAttr -> FieldAttr -> Bool)
-> (FieldAttr -> FieldAttr -> Bool)
-> (FieldAttr -> FieldAttr -> Bool)
-> (FieldAttr -> FieldAttr -> Bool)
-> (FieldAttr -> FieldAttr -> FieldAttr)
-> (FieldAttr -> FieldAttr -> FieldAttr)
-> Ord FieldAttr
FieldAttr -> FieldAttr -> Bool
FieldAttr -> FieldAttr -> Ordering
FieldAttr -> FieldAttr -> FieldAttr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldAttr -> FieldAttr -> Ordering
compare :: FieldAttr -> FieldAttr -> Ordering
$c< :: FieldAttr -> FieldAttr -> Bool
< :: FieldAttr -> FieldAttr -> Bool
$c<= :: FieldAttr -> FieldAttr -> Bool
<= :: FieldAttr -> FieldAttr -> Bool
$c> :: FieldAttr -> FieldAttr -> Bool
> :: FieldAttr -> FieldAttr -> Bool
$c>= :: FieldAttr -> FieldAttr -> Bool
>= :: FieldAttr -> FieldAttr -> Bool
$cmax :: FieldAttr -> FieldAttr -> FieldAttr
max :: FieldAttr -> FieldAttr -> FieldAttr
$cmin :: FieldAttr -> FieldAttr -> FieldAttr
min :: FieldAttr -> FieldAttr -> FieldAttr
Ord, (forall (m :: * -> *). Quote m => FieldAttr -> m Exp)
-> (forall (m :: * -> *). Quote m => FieldAttr -> Code m FieldAttr)
-> Lift FieldAttr
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldAttr -> m Exp
forall (m :: * -> *). Quote m => FieldAttr -> Code m FieldAttr
$clift :: forall (m :: * -> *). Quote m => FieldAttr -> m Exp
lift :: forall (m :: * -> *). Quote m => FieldAttr -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => FieldAttr -> Code m FieldAttr
liftTyped :: forall (m :: * -> *). Quote m => FieldAttr -> Code m FieldAttr
Lift)

-- | 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
parseFieldAttrs :: [Text] -> [FieldAttr]
parseFieldAttrs :: [Text] -> [FieldAttr]
parseFieldAttrs = (Text -> FieldAttr) -> [Text] -> [FieldAttr]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Text -> FieldAttr) -> [Text] -> [FieldAttr])
-> (Text -> FieldAttr) -> [Text] -> [FieldAttr]
forall a b. (a -> b) -> a -> b
$ \case
    Text
"Maybe" -> FieldAttr
FieldAttrMaybe
    Text
"nullable" -> FieldAttr
FieldAttrNullable
    Text
"MigrationOnly" -> FieldAttr
FieldAttrMigrationOnly
    Text
"SafeToRemove" -> FieldAttr
FieldAttrSafeToRemove
    Text
"noreference" -> FieldAttr
FieldAttrNoreference
    Text
raw
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"reference=" Text
raw -> Text -> FieldAttr
FieldAttrReference Text
x
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"constraint=" Text
raw -> Text -> FieldAttr
FieldAttrConstraint Text
x
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"default=" Text
raw -> Text -> FieldAttr
FieldAttrDefault Text
x
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"sqltype=" Text
raw -> Text -> FieldAttr
FieldAttrSqltype Text
x
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"maxlen=" Text
raw -> case ReadS Integer
forall a. Read a => ReadS a
reads (Text -> [Char]
T.unpack Text
x) of
            [(Integer
n, [Char]
s)] | (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isSpace [Char]
s -> Integer -> FieldAttr
FieldAttrMaxlen Integer
n
            [(Integer, [Char])]
_ -> [Char] -> FieldAttr
forall a. HasCallStack => [Char] -> a
error ([Char] -> FieldAttr) -> [Char] -> FieldAttr
forall a b. (a -> b) -> a -> b
$ [Char]
"Could not parse maxlen field with value " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> [Char]
forall a. Show a => a -> [Char]
show Text
raw
        | Just Text
x <- Text -> Text -> Maybe Text
T.stripPrefix Text
"sql=" Text
raw ->
            Text -> FieldAttr
FieldAttrSql Text
x
        | Bool
otherwise -> Text -> FieldAttr
FieldAttrOther Text
raw

-- | 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")
-- @
data FieldType
    = FTTypeCon (Maybe Text) Text
    -- ^ Optional module and name.
    | FTLit FieldTypeLit
    | FTTypePromoted Text
    | FTApp FieldType FieldType
    | FTList FieldType
    deriving (Int -> FieldType -> ShowS
[FieldType] -> ShowS
FieldType -> [Char]
(Int -> FieldType -> ShowS)
-> (FieldType -> [Char])
-> ([FieldType] -> ShowS)
-> Show FieldType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldType -> ShowS
showsPrec :: Int -> FieldType -> ShowS
$cshow :: FieldType -> [Char]
show :: FieldType -> [Char]
$cshowList :: [FieldType] -> ShowS
showList :: [FieldType] -> ShowS
Show, FieldType -> FieldType -> Bool
(FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool) -> Eq FieldType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldType -> FieldType -> Bool
== :: FieldType -> FieldType -> Bool
$c/= :: FieldType -> FieldType -> Bool
/= :: FieldType -> FieldType -> Bool
Eq, ReadPrec [FieldType]
ReadPrec FieldType
Int -> ReadS FieldType
ReadS [FieldType]
(Int -> ReadS FieldType)
-> ReadS [FieldType]
-> ReadPrec FieldType
-> ReadPrec [FieldType]
-> Read FieldType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldType
readsPrec :: Int -> ReadS FieldType
$creadList :: ReadS [FieldType]
readList :: ReadS [FieldType]
$creadPrec :: ReadPrec FieldType
readPrec :: ReadPrec FieldType
$creadListPrec :: ReadPrec [FieldType]
readListPrec :: ReadPrec [FieldType]
Read, Eq FieldType
Eq FieldType =>
(FieldType -> FieldType -> Ordering)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> Ord FieldType
FieldType -> FieldType -> Bool
FieldType -> FieldType -> Ordering
FieldType -> FieldType -> FieldType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldType -> FieldType -> Ordering
compare :: FieldType -> FieldType -> Ordering
$c< :: FieldType -> FieldType -> Bool
< :: FieldType -> FieldType -> Bool
$c<= :: FieldType -> FieldType -> Bool
<= :: FieldType -> FieldType -> Bool
$c> :: FieldType -> FieldType -> Bool
> :: FieldType -> FieldType -> Bool
$c>= :: FieldType -> FieldType -> Bool
>= :: FieldType -> FieldType -> Bool
$cmax :: FieldType -> FieldType -> FieldType
max :: FieldType -> FieldType -> FieldType
$cmin :: FieldType -> FieldType -> FieldType
min :: FieldType -> FieldType -> FieldType
Ord, (forall (m :: * -> *). Quote m => FieldType -> m Exp)
-> (forall (m :: * -> *). Quote m => FieldType -> Code m FieldType)
-> Lift FieldType
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldType -> m Exp
forall (m :: * -> *). Quote m => FieldType -> Code m FieldType
$clift :: forall (m :: * -> *). Quote m => FieldType -> m Exp
lift :: forall (m :: * -> *). Quote m => FieldType -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => FieldType -> Code m FieldType
liftTyped :: forall (m :: * -> *). Quote m => FieldType -> Code m FieldType
Lift)

data FieldTypeLit
    = IntTypeLit Integer
    | TextTypeLit Text
    deriving (Int -> FieldTypeLit -> ShowS
[FieldTypeLit] -> ShowS
FieldTypeLit -> [Char]
(Int -> FieldTypeLit -> ShowS)
-> (FieldTypeLit -> [Char])
-> ([FieldTypeLit] -> ShowS)
-> Show FieldTypeLit
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldTypeLit -> ShowS
showsPrec :: Int -> FieldTypeLit -> ShowS
$cshow :: FieldTypeLit -> [Char]
show :: FieldTypeLit -> [Char]
$cshowList :: [FieldTypeLit] -> ShowS
showList :: [FieldTypeLit] -> ShowS
Show, FieldTypeLit -> FieldTypeLit -> Bool
(FieldTypeLit -> FieldTypeLit -> Bool)
-> (FieldTypeLit -> FieldTypeLit -> Bool) -> Eq FieldTypeLit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldTypeLit -> FieldTypeLit -> Bool
== :: FieldTypeLit -> FieldTypeLit -> Bool
$c/= :: FieldTypeLit -> FieldTypeLit -> Bool
/= :: FieldTypeLit -> FieldTypeLit -> Bool
Eq, ReadPrec [FieldTypeLit]
ReadPrec FieldTypeLit
Int -> ReadS FieldTypeLit
ReadS [FieldTypeLit]
(Int -> ReadS FieldTypeLit)
-> ReadS [FieldTypeLit]
-> ReadPrec FieldTypeLit
-> ReadPrec [FieldTypeLit]
-> Read FieldTypeLit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldTypeLit
readsPrec :: Int -> ReadS FieldTypeLit
$creadList :: ReadS [FieldTypeLit]
readList :: ReadS [FieldTypeLit]
$creadPrec :: ReadPrec FieldTypeLit
readPrec :: ReadPrec FieldTypeLit
$creadListPrec :: ReadPrec [FieldTypeLit]
readListPrec :: ReadPrec [FieldTypeLit]
Read, Eq FieldTypeLit
Eq FieldTypeLit =>
(FieldTypeLit -> FieldTypeLit -> Ordering)
-> (FieldTypeLit -> FieldTypeLit -> Bool)
-> (FieldTypeLit -> FieldTypeLit -> Bool)
-> (FieldTypeLit -> FieldTypeLit -> Bool)
-> (FieldTypeLit -> FieldTypeLit -> Bool)
-> (FieldTypeLit -> FieldTypeLit -> FieldTypeLit)
-> (FieldTypeLit -> FieldTypeLit -> FieldTypeLit)
-> Ord FieldTypeLit
FieldTypeLit -> FieldTypeLit -> Bool
FieldTypeLit -> FieldTypeLit -> Ordering
FieldTypeLit -> FieldTypeLit -> FieldTypeLit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldTypeLit -> FieldTypeLit -> Ordering
compare :: FieldTypeLit -> FieldTypeLit -> Ordering
$c< :: FieldTypeLit -> FieldTypeLit -> Bool
< :: FieldTypeLit -> FieldTypeLit -> Bool
$c<= :: FieldTypeLit -> FieldTypeLit -> Bool
<= :: FieldTypeLit -> FieldTypeLit -> Bool
$c> :: FieldTypeLit -> FieldTypeLit -> Bool
> :: FieldTypeLit -> FieldTypeLit -> Bool
$c>= :: FieldTypeLit -> FieldTypeLit -> Bool
>= :: FieldTypeLit -> FieldTypeLit -> Bool
$cmax :: FieldTypeLit -> FieldTypeLit -> FieldTypeLit
max :: FieldTypeLit -> FieldTypeLit -> FieldTypeLit
$cmin :: FieldTypeLit -> FieldTypeLit -> FieldTypeLit
min :: FieldTypeLit -> FieldTypeLit -> FieldTypeLit
Ord, (forall (m :: * -> *). Quote m => FieldTypeLit -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    FieldTypeLit -> Code m FieldTypeLit)
-> Lift FieldTypeLit
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldTypeLit -> m Exp
forall (m :: * -> *).
Quote m =>
FieldTypeLit -> Code m FieldTypeLit
$clift :: forall (m :: * -> *). Quote m => FieldTypeLit -> m Exp
lift :: forall (m :: * -> *). Quote m => FieldTypeLit -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
FieldTypeLit -> Code m FieldTypeLit
liftTyped :: forall (m :: * -> *).
Quote m =>
FieldTypeLit -> Code m FieldTypeLit
Lift)

isFieldNotGenerated :: FieldDef -> Bool
isFieldNotGenerated :: FieldDef -> Bool
isFieldNotGenerated = Maybe Text -> Bool
forall a. Maybe a -> Bool
isNothing (Maybe Text -> Bool)
-> (FieldDef -> Maybe Text) -> FieldDef -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldDef -> Maybe Text
fieldGenerated

-- | There are 3 kinds of references
-- 1) composite (to fields that exist in the record)
-- 2) single field
-- 3) embedded
data ReferenceDef
    = 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).
    deriving (Int -> ReferenceDef -> ShowS
[ReferenceDef] -> ShowS
ReferenceDef -> [Char]
(Int -> ReferenceDef -> ShowS)
-> (ReferenceDef -> [Char])
-> ([ReferenceDef] -> ShowS)
-> Show ReferenceDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReferenceDef -> ShowS
showsPrec :: Int -> ReferenceDef -> ShowS
$cshow :: ReferenceDef -> [Char]
show :: ReferenceDef -> [Char]
$cshowList :: [ReferenceDef] -> ShowS
showList :: [ReferenceDef] -> ShowS
Show, ReferenceDef -> ReferenceDef -> Bool
(ReferenceDef -> ReferenceDef -> Bool)
-> (ReferenceDef -> ReferenceDef -> Bool) -> Eq ReferenceDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReferenceDef -> ReferenceDef -> Bool
== :: ReferenceDef -> ReferenceDef -> Bool
$c/= :: ReferenceDef -> ReferenceDef -> Bool
/= :: ReferenceDef -> ReferenceDef -> Bool
Eq, ReadPrec [ReferenceDef]
ReadPrec ReferenceDef
Int -> ReadS ReferenceDef
ReadS [ReferenceDef]
(Int -> ReadS ReferenceDef)
-> ReadS [ReferenceDef]
-> ReadPrec ReferenceDef
-> ReadPrec [ReferenceDef]
-> Read ReferenceDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReferenceDef
readsPrec :: Int -> ReadS ReferenceDef
$creadList :: ReadS [ReferenceDef]
readList :: ReadS [ReferenceDef]
$creadPrec :: ReadPrec ReferenceDef
readPrec :: ReadPrec ReferenceDef
$creadListPrec :: ReadPrec [ReferenceDef]
readListPrec :: ReadPrec [ReferenceDef]
Read, Eq ReferenceDef
Eq ReferenceDef =>
(ReferenceDef -> ReferenceDef -> Ordering)
-> (ReferenceDef -> ReferenceDef -> Bool)
-> (ReferenceDef -> ReferenceDef -> Bool)
-> (ReferenceDef -> ReferenceDef -> Bool)
-> (ReferenceDef -> ReferenceDef -> Bool)
-> (ReferenceDef -> ReferenceDef -> ReferenceDef)
-> (ReferenceDef -> ReferenceDef -> ReferenceDef)
-> Ord ReferenceDef
ReferenceDef -> ReferenceDef -> Bool
ReferenceDef -> ReferenceDef -> Ordering
ReferenceDef -> ReferenceDef -> ReferenceDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReferenceDef -> ReferenceDef -> Ordering
compare :: ReferenceDef -> ReferenceDef -> Ordering
$c< :: ReferenceDef -> ReferenceDef -> Bool
< :: ReferenceDef -> ReferenceDef -> Bool
$c<= :: ReferenceDef -> ReferenceDef -> Bool
<= :: ReferenceDef -> ReferenceDef -> Bool
$c> :: ReferenceDef -> ReferenceDef -> Bool
> :: ReferenceDef -> ReferenceDef -> Bool
$c>= :: ReferenceDef -> ReferenceDef -> Bool
>= :: ReferenceDef -> ReferenceDef -> Bool
$cmax :: ReferenceDef -> ReferenceDef -> ReferenceDef
max :: ReferenceDef -> ReferenceDef -> ReferenceDef
$cmin :: ReferenceDef -> ReferenceDef -> ReferenceDef
min :: ReferenceDef -> ReferenceDef -> ReferenceDef
Ord, (forall (m :: * -> *). Quote m => ReferenceDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    ReferenceDef -> Code m ReferenceDef)
-> Lift ReferenceDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ReferenceDef -> m Exp
forall (m :: * -> *).
Quote m =>
ReferenceDef -> Code m ReferenceDef
$clift :: forall (m :: * -> *). Quote m => ReferenceDef -> m Exp
lift :: forall (m :: * -> *). Quote m => ReferenceDef -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
ReferenceDef -> Code m ReferenceDef
liftTyped :: forall (m :: * -> *).
Quote m =>
ReferenceDef -> Code m ReferenceDef
Lift)

-- | An EmbedEntityDef is the same as an EntityDef
-- But it is only used for fieldReference
-- so it only has data needed for embedding
data EmbedEntityDef = EmbedEntityDef
    { EmbedEntityDef -> EntityNameHS
embeddedHaskell :: EntityNameHS
    , EmbedEntityDef -> [EmbedFieldDef]
embeddedFields  :: [EmbedFieldDef]
    } deriving (Int -> EmbedEntityDef -> ShowS
[EmbedEntityDef] -> ShowS
EmbedEntityDef -> [Char]
(Int -> EmbedEntityDef -> ShowS)
-> (EmbedEntityDef -> [Char])
-> ([EmbedEntityDef] -> ShowS)
-> Show EmbedEntityDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EmbedEntityDef -> ShowS
showsPrec :: Int -> EmbedEntityDef -> ShowS
$cshow :: EmbedEntityDef -> [Char]
show :: EmbedEntityDef -> [Char]
$cshowList :: [EmbedEntityDef] -> ShowS
showList :: [EmbedEntityDef] -> ShowS
Show, EmbedEntityDef -> EmbedEntityDef -> Bool
(EmbedEntityDef -> EmbedEntityDef -> Bool)
-> (EmbedEntityDef -> EmbedEntityDef -> Bool) -> Eq EmbedEntityDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EmbedEntityDef -> EmbedEntityDef -> Bool
== :: EmbedEntityDef -> EmbedEntityDef -> Bool
$c/= :: EmbedEntityDef -> EmbedEntityDef -> Bool
/= :: EmbedEntityDef -> EmbedEntityDef -> Bool
Eq, ReadPrec [EmbedEntityDef]
ReadPrec EmbedEntityDef
Int -> ReadS EmbedEntityDef
ReadS [EmbedEntityDef]
(Int -> ReadS EmbedEntityDef)
-> ReadS [EmbedEntityDef]
-> ReadPrec EmbedEntityDef
-> ReadPrec [EmbedEntityDef]
-> Read EmbedEntityDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EmbedEntityDef
readsPrec :: Int -> ReadS EmbedEntityDef
$creadList :: ReadS [EmbedEntityDef]
readList :: ReadS [EmbedEntityDef]
$creadPrec :: ReadPrec EmbedEntityDef
readPrec :: ReadPrec EmbedEntityDef
$creadListPrec :: ReadPrec [EmbedEntityDef]
readListPrec :: ReadPrec [EmbedEntityDef]
Read, Eq EmbedEntityDef
Eq EmbedEntityDef =>
(EmbedEntityDef -> EmbedEntityDef -> Ordering)
-> (EmbedEntityDef -> EmbedEntityDef -> Bool)
-> (EmbedEntityDef -> EmbedEntityDef -> Bool)
-> (EmbedEntityDef -> EmbedEntityDef -> Bool)
-> (EmbedEntityDef -> EmbedEntityDef -> Bool)
-> (EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef)
-> (EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef)
-> Ord EmbedEntityDef
EmbedEntityDef -> EmbedEntityDef -> Bool
EmbedEntityDef -> EmbedEntityDef -> Ordering
EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EmbedEntityDef -> EmbedEntityDef -> Ordering
compare :: EmbedEntityDef -> EmbedEntityDef -> Ordering
$c< :: EmbedEntityDef -> EmbedEntityDef -> Bool
< :: EmbedEntityDef -> EmbedEntityDef -> Bool
$c<= :: EmbedEntityDef -> EmbedEntityDef -> Bool
<= :: EmbedEntityDef -> EmbedEntityDef -> Bool
$c> :: EmbedEntityDef -> EmbedEntityDef -> Bool
> :: EmbedEntityDef -> EmbedEntityDef -> Bool
$c>= :: EmbedEntityDef -> EmbedEntityDef -> Bool
>= :: EmbedEntityDef -> EmbedEntityDef -> Bool
$cmax :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef
max :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef
$cmin :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef
min :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef
Ord, (forall (m :: * -> *). Quote m => EmbedEntityDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    EmbedEntityDef -> Code m EmbedEntityDef)
-> Lift EmbedEntityDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EmbedEntityDef -> m Exp
forall (m :: * -> *).
Quote m =>
EmbedEntityDef -> Code m EmbedEntityDef
$clift :: forall (m :: * -> *). Quote m => EmbedEntityDef -> m Exp
lift :: forall (m :: * -> *). Quote m => EmbedEntityDef -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
EmbedEntityDef -> Code m EmbedEntityDef
liftTyped :: forall (m :: * -> *).
Quote m =>
EmbedEntityDef -> Code m EmbedEntityDef
Lift)

-- | An EmbedFieldDef is the same as a FieldDef
-- But it is only used for embeddedFields
-- so it only has data needed for embedding
data EmbedFieldDef = EmbedFieldDef
    { EmbedFieldDef -> FieldNameDB
emFieldDB    :: FieldNameDB
    , EmbedFieldDef -> Maybe (Either SelfEmbed EntityNameHS)
emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)
    }
    deriving (Int -> EmbedFieldDef -> ShowS
[EmbedFieldDef] -> ShowS
EmbedFieldDef -> [Char]
(Int -> EmbedFieldDef -> ShowS)
-> (EmbedFieldDef -> [Char])
-> ([EmbedFieldDef] -> ShowS)
-> Show EmbedFieldDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EmbedFieldDef -> ShowS
showsPrec :: Int -> EmbedFieldDef -> ShowS
$cshow :: EmbedFieldDef -> [Char]
show :: EmbedFieldDef -> [Char]
$cshowList :: [EmbedFieldDef] -> ShowS
showList :: [EmbedFieldDef] -> ShowS
Show, EmbedFieldDef -> EmbedFieldDef -> Bool
(EmbedFieldDef -> EmbedFieldDef -> Bool)
-> (EmbedFieldDef -> EmbedFieldDef -> Bool) -> Eq EmbedFieldDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EmbedFieldDef -> EmbedFieldDef -> Bool
== :: EmbedFieldDef -> EmbedFieldDef -> Bool
$c/= :: EmbedFieldDef -> EmbedFieldDef -> Bool
/= :: EmbedFieldDef -> EmbedFieldDef -> Bool
Eq, ReadPrec [EmbedFieldDef]
ReadPrec EmbedFieldDef
Int -> ReadS EmbedFieldDef
ReadS [EmbedFieldDef]
(Int -> ReadS EmbedFieldDef)
-> ReadS [EmbedFieldDef]
-> ReadPrec EmbedFieldDef
-> ReadPrec [EmbedFieldDef]
-> Read EmbedFieldDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EmbedFieldDef
readsPrec :: Int -> ReadS EmbedFieldDef
$creadList :: ReadS [EmbedFieldDef]
readList :: ReadS [EmbedFieldDef]
$creadPrec :: ReadPrec EmbedFieldDef
readPrec :: ReadPrec EmbedFieldDef
$creadListPrec :: ReadPrec [EmbedFieldDef]
readListPrec :: ReadPrec [EmbedFieldDef]
Read, Eq EmbedFieldDef
Eq EmbedFieldDef =>
(EmbedFieldDef -> EmbedFieldDef -> Ordering)
-> (EmbedFieldDef -> EmbedFieldDef -> Bool)
-> (EmbedFieldDef -> EmbedFieldDef -> Bool)
-> (EmbedFieldDef -> EmbedFieldDef -> Bool)
-> (EmbedFieldDef -> EmbedFieldDef -> Bool)
-> (EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef)
-> (EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef)
-> Ord EmbedFieldDef
EmbedFieldDef -> EmbedFieldDef -> Bool
EmbedFieldDef -> EmbedFieldDef -> Ordering
EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EmbedFieldDef -> EmbedFieldDef -> Ordering
compare :: EmbedFieldDef -> EmbedFieldDef -> Ordering
$c< :: EmbedFieldDef -> EmbedFieldDef -> Bool
< :: EmbedFieldDef -> EmbedFieldDef -> Bool
$c<= :: EmbedFieldDef -> EmbedFieldDef -> Bool
<= :: EmbedFieldDef -> EmbedFieldDef -> Bool
$c> :: EmbedFieldDef -> EmbedFieldDef -> Bool
> :: EmbedFieldDef -> EmbedFieldDef -> Bool
$c>= :: EmbedFieldDef -> EmbedFieldDef -> Bool
>= :: EmbedFieldDef -> EmbedFieldDef -> Bool
$cmax :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef
max :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef
$cmin :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef
min :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef
Ord, (forall (m :: * -> *). Quote m => EmbedFieldDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    EmbedFieldDef -> Code m EmbedFieldDef)
-> Lift EmbedFieldDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EmbedFieldDef -> m Exp
forall (m :: * -> *).
Quote m =>
EmbedFieldDef -> Code m EmbedFieldDef
$clift :: forall (m :: * -> *). Quote m => EmbedFieldDef -> m Exp
lift :: forall (m :: * -> *). Quote m => EmbedFieldDef -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
EmbedFieldDef -> Code m EmbedFieldDef
liftTyped :: forall (m :: * -> *).
Quote m =>
EmbedFieldDef -> Code m EmbedFieldDef
Lift)

data SelfEmbed = SelfEmbed
    deriving (Int -> SelfEmbed -> ShowS
[SelfEmbed] -> ShowS
SelfEmbed -> [Char]
(Int -> SelfEmbed -> ShowS)
-> (SelfEmbed -> [Char])
-> ([SelfEmbed] -> ShowS)
-> Show SelfEmbed
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelfEmbed -> ShowS
showsPrec :: Int -> SelfEmbed -> ShowS
$cshow :: SelfEmbed -> [Char]
show :: SelfEmbed -> [Char]
$cshowList :: [SelfEmbed] -> ShowS
showList :: [SelfEmbed] -> ShowS
Show, SelfEmbed -> SelfEmbed -> Bool
(SelfEmbed -> SelfEmbed -> Bool)
-> (SelfEmbed -> SelfEmbed -> Bool) -> Eq SelfEmbed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelfEmbed -> SelfEmbed -> Bool
== :: SelfEmbed -> SelfEmbed -> Bool
$c/= :: SelfEmbed -> SelfEmbed -> Bool
/= :: SelfEmbed -> SelfEmbed -> Bool
Eq, ReadPrec [SelfEmbed]
ReadPrec SelfEmbed
Int -> ReadS SelfEmbed
ReadS [SelfEmbed]
(Int -> ReadS SelfEmbed)
-> ReadS [SelfEmbed]
-> ReadPrec SelfEmbed
-> ReadPrec [SelfEmbed]
-> Read SelfEmbed
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelfEmbed
readsPrec :: Int -> ReadS SelfEmbed
$creadList :: ReadS [SelfEmbed]
readList :: ReadS [SelfEmbed]
$creadPrec :: ReadPrec SelfEmbed
readPrec :: ReadPrec SelfEmbed
$creadListPrec :: ReadPrec [SelfEmbed]
readListPrec :: ReadPrec [SelfEmbed]
Read, Eq SelfEmbed
Eq SelfEmbed =>
(SelfEmbed -> SelfEmbed -> Ordering)
-> (SelfEmbed -> SelfEmbed -> Bool)
-> (SelfEmbed -> SelfEmbed -> Bool)
-> (SelfEmbed -> SelfEmbed -> Bool)
-> (SelfEmbed -> SelfEmbed -> Bool)
-> (SelfEmbed -> SelfEmbed -> SelfEmbed)
-> (SelfEmbed -> SelfEmbed -> SelfEmbed)
-> Ord SelfEmbed
SelfEmbed -> SelfEmbed -> Bool
SelfEmbed -> SelfEmbed -> Ordering
SelfEmbed -> SelfEmbed -> SelfEmbed
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SelfEmbed -> SelfEmbed -> Ordering
compare :: SelfEmbed -> SelfEmbed -> Ordering
$c< :: SelfEmbed -> SelfEmbed -> Bool
< :: SelfEmbed -> SelfEmbed -> Bool
$c<= :: SelfEmbed -> SelfEmbed -> Bool
<= :: SelfEmbed -> SelfEmbed -> Bool
$c> :: SelfEmbed -> SelfEmbed -> Bool
> :: SelfEmbed -> SelfEmbed -> Bool
$c>= :: SelfEmbed -> SelfEmbed -> Bool
>= :: SelfEmbed -> SelfEmbed -> Bool
$cmax :: SelfEmbed -> SelfEmbed -> SelfEmbed
max :: SelfEmbed -> SelfEmbed -> SelfEmbed
$cmin :: SelfEmbed -> SelfEmbed -> SelfEmbed
min :: SelfEmbed -> SelfEmbed -> SelfEmbed
Ord, (forall (m :: * -> *). Quote m => SelfEmbed -> m Exp)
-> (forall (m :: * -> *). Quote m => SelfEmbed -> Code m SelfEmbed)
-> Lift SelfEmbed
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SelfEmbed -> m Exp
forall (m :: * -> *). Quote m => SelfEmbed -> Code m SelfEmbed
$clift :: forall (m :: * -> *). Quote m => SelfEmbed -> m Exp
lift :: forall (m :: * -> *). Quote m => SelfEmbed -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => SelfEmbed -> Code m SelfEmbed
liftTyped :: forall (m :: * -> *). Quote m => SelfEmbed -> Code m SelfEmbed
Lift)

-- | Returns 'True' if the 'FieldDef' does not have a 'MigrationOnly' or
-- 'SafeToRemove' flag from the QuasiQuoter.
--
-- @since 2.13.0.0
isHaskellField :: FieldDef -> Bool
isHaskellField :: FieldDef -> Bool
isHaskellField FieldDef
fd =
    FieldAttr
FieldAttrMigrationOnly FieldAttr -> [FieldAttr] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` FieldDef -> [FieldAttr]
fieldAttrs FieldDef
fd Bool -> Bool -> Bool
&&
    FieldAttr
FieldAttrSafeToRemove FieldAttr -> [FieldAttr] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` FieldDef -> [FieldAttr]
fieldAttrs FieldDef
fd

toEmbedEntityDef :: EntityDef -> EmbedEntityDef
toEmbedEntityDef :: EntityDef -> EmbedEntityDef
toEmbedEntityDef EntityDef
ent = EmbedEntityDef
embDef
  where
    embDef :: EmbedEntityDef
embDef = EmbedEntityDef
        { embeddedHaskell :: EntityNameHS
embeddedHaskell = EntityDef -> EntityNameHS
entityHaskell EntityDef
ent
        , embeddedFields :: [EmbedFieldDef]
embeddedFields =
            (FieldDef -> EmbedFieldDef) -> [FieldDef] -> [EmbedFieldDef]
forall a b. (a -> b) -> [a] -> [b]
map FieldDef -> EmbedFieldDef
toEmbedFieldDef
            ([FieldDef] -> [EmbedFieldDef]) -> [FieldDef] -> [EmbedFieldDef]
forall a b. (a -> b) -> a -> b
$ (FieldDef -> Bool) -> [FieldDef] -> [FieldDef]
forall a. (a -> Bool) -> [a] -> [a]
filter FieldDef -> Bool
isHaskellField
            ([FieldDef] -> [FieldDef]) -> [FieldDef] -> [FieldDef]
forall a b. (a -> b) -> a -> b
$ EntityDef -> [FieldDef]
entityFields EntityDef
ent
        }
    toEmbedFieldDef :: FieldDef -> EmbedFieldDef
    toEmbedFieldDef :: FieldDef -> EmbedFieldDef
toEmbedFieldDef FieldDef
field =
        EmbedFieldDef
            { emFieldDB :: FieldNameDB
emFieldDB =
                FieldDef -> FieldNameDB
fieldDB FieldDef
field
            , emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)
emFieldEmbed =
                case FieldDef -> ReferenceDef
fieldReference FieldDef
field of
                    EmbedRef EntityNameHS
em ->
                        Either SelfEmbed EntityNameHS
-> Maybe (Either SelfEmbed EntityNameHS)
forall a. a -> Maybe a
Just (Either SelfEmbed EntityNameHS
 -> Maybe (Either SelfEmbed EntityNameHS))
-> Either SelfEmbed EntityNameHS
-> Maybe (Either SelfEmbed EntityNameHS)
forall a b. (a -> b) -> a -> b
$ EntityNameHS -> Either SelfEmbed EntityNameHS
forall a b. b -> Either a b
Right EntityNameHS
em
                    ReferenceDef
SelfReference -> Either SelfEmbed EntityNameHS
-> Maybe (Either SelfEmbed EntityNameHS)
forall a. a -> Maybe a
Just (Either SelfEmbed EntityNameHS
 -> Maybe (Either SelfEmbed EntityNameHS))
-> Either SelfEmbed EntityNameHS
-> Maybe (Either SelfEmbed EntityNameHS)
forall a b. (a -> b) -> a -> b
$ SelfEmbed -> Either SelfEmbed EntityNameHS
forall a b. a -> Either a b
Left SelfEmbed
SelfEmbed
                    ReferenceDef
_ -> Maybe (Either SelfEmbed EntityNameHS)
forall a. Maybe a
Nothing
            }

-- | 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 = []
--     }
-- @
--
data UniqueDef = UniqueDef
    { UniqueDef -> ConstraintNameHS
uniqueHaskell :: !ConstraintNameHS
    , UniqueDef -> ConstraintNameDB
uniqueDBName  :: !ConstraintNameDB
    , UniqueDef -> NonEmpty (FieldNameHS, FieldNameDB)
uniqueFields  :: !(NonEmpty (FieldNameHS, FieldNameDB))
    , UniqueDef -> [Text]
uniqueAttrs   :: ![Attr]
    }
    deriving (Int -> UniqueDef -> ShowS
[UniqueDef] -> ShowS
UniqueDef -> [Char]
(Int -> UniqueDef -> ShowS)
-> (UniqueDef -> [Char])
-> ([UniqueDef] -> ShowS)
-> Show UniqueDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UniqueDef -> ShowS
showsPrec :: Int -> UniqueDef -> ShowS
$cshow :: UniqueDef -> [Char]
show :: UniqueDef -> [Char]
$cshowList :: [UniqueDef] -> ShowS
showList :: [UniqueDef] -> ShowS
Show, UniqueDef -> UniqueDef -> Bool
(UniqueDef -> UniqueDef -> Bool)
-> (UniqueDef -> UniqueDef -> Bool) -> Eq UniqueDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UniqueDef -> UniqueDef -> Bool
== :: UniqueDef -> UniqueDef -> Bool
$c/= :: UniqueDef -> UniqueDef -> Bool
/= :: UniqueDef -> UniqueDef -> Bool
Eq, ReadPrec [UniqueDef]
ReadPrec UniqueDef
Int -> ReadS UniqueDef
ReadS [UniqueDef]
(Int -> ReadS UniqueDef)
-> ReadS [UniqueDef]
-> ReadPrec UniqueDef
-> ReadPrec [UniqueDef]
-> Read UniqueDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UniqueDef
readsPrec :: Int -> ReadS UniqueDef
$creadList :: ReadS [UniqueDef]
readList :: ReadS [UniqueDef]
$creadPrec :: ReadPrec UniqueDef
readPrec :: ReadPrec UniqueDef
$creadListPrec :: ReadPrec [UniqueDef]
readListPrec :: ReadPrec [UniqueDef]
Read, Eq UniqueDef
Eq UniqueDef =>
(UniqueDef -> UniqueDef -> Ordering)
-> (UniqueDef -> UniqueDef -> Bool)
-> (UniqueDef -> UniqueDef -> Bool)
-> (UniqueDef -> UniqueDef -> Bool)
-> (UniqueDef -> UniqueDef -> Bool)
-> (UniqueDef -> UniqueDef -> UniqueDef)
-> (UniqueDef -> UniqueDef -> UniqueDef)
-> Ord UniqueDef
UniqueDef -> UniqueDef -> Bool
UniqueDef -> UniqueDef -> Ordering
UniqueDef -> UniqueDef -> UniqueDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UniqueDef -> UniqueDef -> Ordering
compare :: UniqueDef -> UniqueDef -> Ordering
$c< :: UniqueDef -> UniqueDef -> Bool
< :: UniqueDef -> UniqueDef -> Bool
$c<= :: UniqueDef -> UniqueDef -> Bool
<= :: UniqueDef -> UniqueDef -> Bool
$c> :: UniqueDef -> UniqueDef -> Bool
> :: UniqueDef -> UniqueDef -> Bool
$c>= :: UniqueDef -> UniqueDef -> Bool
>= :: UniqueDef -> UniqueDef -> Bool
$cmax :: UniqueDef -> UniqueDef -> UniqueDef
max :: UniqueDef -> UniqueDef -> UniqueDef
$cmin :: UniqueDef -> UniqueDef -> UniqueDef
min :: UniqueDef -> UniqueDef -> UniqueDef
Ord, (forall (m :: * -> *). Quote m => UniqueDef -> m Exp)
-> (forall (m :: * -> *). Quote m => UniqueDef -> Code m UniqueDef)
-> Lift UniqueDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => UniqueDef -> m Exp
forall (m :: * -> *). Quote m => UniqueDef -> Code m UniqueDef
$clift :: forall (m :: * -> *). Quote m => UniqueDef -> m Exp
lift :: forall (m :: * -> *). Quote m => UniqueDef -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => UniqueDef -> Code m UniqueDef
liftTyped :: forall (m :: * -> *). Quote m => UniqueDef -> Code m UniqueDef
Lift)

data CompositeDef = CompositeDef
    { CompositeDef -> NonEmpty FieldDef
compositeFields  :: !(NonEmpty FieldDef)
    , CompositeDef -> [Text]
compositeAttrs   :: ![Attr]
    }
    deriving (Int -> CompositeDef -> ShowS
[CompositeDef] -> ShowS
CompositeDef -> [Char]
(Int -> CompositeDef -> ShowS)
-> (CompositeDef -> [Char])
-> ([CompositeDef] -> ShowS)
-> Show CompositeDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompositeDef -> ShowS
showsPrec :: Int -> CompositeDef -> ShowS
$cshow :: CompositeDef -> [Char]
show :: CompositeDef -> [Char]
$cshowList :: [CompositeDef] -> ShowS
showList :: [CompositeDef] -> ShowS
Show, CompositeDef -> CompositeDef -> Bool
(CompositeDef -> CompositeDef -> Bool)
-> (CompositeDef -> CompositeDef -> Bool) -> Eq CompositeDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompositeDef -> CompositeDef -> Bool
== :: CompositeDef -> CompositeDef -> Bool
$c/= :: CompositeDef -> CompositeDef -> Bool
/= :: CompositeDef -> CompositeDef -> Bool
Eq, ReadPrec [CompositeDef]
ReadPrec CompositeDef
Int -> ReadS CompositeDef
ReadS [CompositeDef]
(Int -> ReadS CompositeDef)
-> ReadS [CompositeDef]
-> ReadPrec CompositeDef
-> ReadPrec [CompositeDef]
-> Read CompositeDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CompositeDef
readsPrec :: Int -> ReadS CompositeDef
$creadList :: ReadS [CompositeDef]
readList :: ReadS [CompositeDef]
$creadPrec :: ReadPrec CompositeDef
readPrec :: ReadPrec CompositeDef
$creadListPrec :: ReadPrec [CompositeDef]
readListPrec :: ReadPrec [CompositeDef]
Read, Eq CompositeDef
Eq CompositeDef =>
(CompositeDef -> CompositeDef -> Ordering)
-> (CompositeDef -> CompositeDef -> Bool)
-> (CompositeDef -> CompositeDef -> Bool)
-> (CompositeDef -> CompositeDef -> Bool)
-> (CompositeDef -> CompositeDef -> Bool)
-> (CompositeDef -> CompositeDef -> CompositeDef)
-> (CompositeDef -> CompositeDef -> CompositeDef)
-> Ord CompositeDef
CompositeDef -> CompositeDef -> Bool
CompositeDef -> CompositeDef -> Ordering
CompositeDef -> CompositeDef -> CompositeDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CompositeDef -> CompositeDef -> Ordering
compare :: CompositeDef -> CompositeDef -> Ordering
$c< :: CompositeDef -> CompositeDef -> Bool
< :: CompositeDef -> CompositeDef -> Bool
$c<= :: CompositeDef -> CompositeDef -> Bool
<= :: CompositeDef -> CompositeDef -> Bool
$c> :: CompositeDef -> CompositeDef -> Bool
> :: CompositeDef -> CompositeDef -> Bool
$c>= :: CompositeDef -> CompositeDef -> Bool
>= :: CompositeDef -> CompositeDef -> Bool
$cmax :: CompositeDef -> CompositeDef -> CompositeDef
max :: CompositeDef -> CompositeDef -> CompositeDef
$cmin :: CompositeDef -> CompositeDef -> CompositeDef
min :: CompositeDef -> CompositeDef -> CompositeDef
Ord, (forall (m :: * -> *). Quote m => CompositeDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    CompositeDef -> Code m CompositeDef)
-> Lift CompositeDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => CompositeDef -> m Exp
forall (m :: * -> *).
Quote m =>
CompositeDef -> Code m CompositeDef
$clift :: forall (m :: * -> *). Quote m => CompositeDef -> m Exp
lift :: forall (m :: * -> *). Quote m => CompositeDef -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
CompositeDef -> Code m CompositeDef
liftTyped :: forall (m :: * -> *).
Quote m =>
CompositeDef -> Code m CompositeDef
Lift)

-- | Used instead of FieldDef
-- to generate a smaller amount of code
type ForeignFieldDef = (FieldNameHS, FieldNameDB)

data ForeignDef = ForeignDef
    { ForeignDef -> EntityNameHS
foreignRefTableHaskell       :: !EntityNameHS
    , ForeignDef -> EntityNameDB
foreignRefTableDBName        :: !EntityNameDB
    , ForeignDef -> ConstraintNameHS
foreignConstraintNameHaskell :: !ConstraintNameHS
    , ForeignDef -> ConstraintNameDB
foreignConstraintNameDBName  :: !ConstraintNameDB
    , ForeignDef -> FieldCascade
foreignFieldCascade          :: !FieldCascade
    -- ^ Determine how the field will cascade on updates and deletions.
    --
    -- @since 2.11.0
    , ForeignDef
-> [((FieldNameHS, FieldNameDB), (FieldNameHS, FieldNameDB))]
foreignFields                :: ![(ForeignFieldDef, ForeignFieldDef)] -- this entity plus the primary entity
    , ForeignDef -> [Text]
foreignAttrs                 :: ![Attr]
    , ForeignDef -> Bool
foreignNullable              :: Bool
    , ForeignDef -> Bool
foreignToPrimary             :: Bool
    -- ^ Determines if the reference is towards a Primary Key or not.
    --
    -- @since 2.11.0
    }
    deriving (Int -> ForeignDef -> ShowS
[ForeignDef] -> ShowS
ForeignDef -> [Char]
(Int -> ForeignDef -> ShowS)
-> (ForeignDef -> [Char])
-> ([ForeignDef] -> ShowS)
-> Show ForeignDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDef -> ShowS
showsPrec :: Int -> ForeignDef -> ShowS
$cshow :: ForeignDef -> [Char]
show :: ForeignDef -> [Char]
$cshowList :: [ForeignDef] -> ShowS
showList :: [ForeignDef] -> ShowS
Show, ForeignDef -> ForeignDef -> Bool
(ForeignDef -> ForeignDef -> Bool)
-> (ForeignDef -> ForeignDef -> Bool) -> Eq ForeignDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDef -> ForeignDef -> Bool
== :: ForeignDef -> ForeignDef -> Bool
$c/= :: ForeignDef -> ForeignDef -> Bool
/= :: ForeignDef -> ForeignDef -> Bool
Eq, ReadPrec [ForeignDef]
ReadPrec ForeignDef
Int -> ReadS ForeignDef
ReadS [ForeignDef]
(Int -> ReadS ForeignDef)
-> ReadS [ForeignDef]
-> ReadPrec ForeignDef
-> ReadPrec [ForeignDef]
-> Read ForeignDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ForeignDef
readsPrec :: Int -> ReadS ForeignDef
$creadList :: ReadS [ForeignDef]
readList :: ReadS [ForeignDef]
$creadPrec :: ReadPrec ForeignDef
readPrec :: ReadPrec ForeignDef
$creadListPrec :: ReadPrec [ForeignDef]
readListPrec :: ReadPrec [ForeignDef]
Read, Eq ForeignDef
Eq ForeignDef =>
(ForeignDef -> ForeignDef -> Ordering)
-> (ForeignDef -> ForeignDef -> Bool)
-> (ForeignDef -> ForeignDef -> Bool)
-> (ForeignDef -> ForeignDef -> Bool)
-> (ForeignDef -> ForeignDef -> Bool)
-> (ForeignDef -> ForeignDef -> ForeignDef)
-> (ForeignDef -> ForeignDef -> ForeignDef)
-> Ord ForeignDef
ForeignDef -> ForeignDef -> Bool
ForeignDef -> ForeignDef -> Ordering
ForeignDef -> ForeignDef -> ForeignDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ForeignDef -> ForeignDef -> Ordering
compare :: ForeignDef -> ForeignDef -> Ordering
$c< :: ForeignDef -> ForeignDef -> Bool
< :: ForeignDef -> ForeignDef -> Bool
$c<= :: ForeignDef -> ForeignDef -> Bool
<= :: ForeignDef -> ForeignDef -> Bool
$c> :: ForeignDef -> ForeignDef -> Bool
> :: ForeignDef -> ForeignDef -> Bool
$c>= :: ForeignDef -> ForeignDef -> Bool
>= :: ForeignDef -> ForeignDef -> Bool
$cmax :: ForeignDef -> ForeignDef -> ForeignDef
max :: ForeignDef -> ForeignDef -> ForeignDef
$cmin :: ForeignDef -> ForeignDef -> ForeignDef
min :: ForeignDef -> ForeignDef -> ForeignDef
Ord, (forall (m :: * -> *). Quote m => ForeignDef -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    ForeignDef -> Code m ForeignDef)
-> Lift ForeignDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ForeignDef -> m Exp
forall (m :: * -> *). Quote m => ForeignDef -> Code m ForeignDef
$clift :: forall (m :: * -> *). Quote m => ForeignDef -> m Exp
lift :: forall (m :: * -> *). Quote m => ForeignDef -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => ForeignDef -> Code m ForeignDef
liftTyped :: forall (m :: * -> *). Quote m => ForeignDef -> Code m ForeignDef
Lift)

-- | 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
data FieldCascade = FieldCascade
    { FieldCascade -> Maybe CascadeAction
fcOnUpdate :: !(Maybe CascadeAction)
    , FieldCascade -> Maybe CascadeAction
fcOnDelete :: !(Maybe CascadeAction)
    }
    deriving (Int -> FieldCascade -> ShowS
[FieldCascade] -> ShowS
FieldCascade -> [Char]
(Int -> FieldCascade -> ShowS)
-> (FieldCascade -> [Char])
-> ([FieldCascade] -> ShowS)
-> Show FieldCascade
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldCascade -> ShowS
showsPrec :: Int -> FieldCascade -> ShowS
$cshow :: FieldCascade -> [Char]
show :: FieldCascade -> [Char]
$cshowList :: [FieldCascade] -> ShowS
showList :: [FieldCascade] -> ShowS
Show, FieldCascade -> FieldCascade -> Bool
(FieldCascade -> FieldCascade -> Bool)
-> (FieldCascade -> FieldCascade -> Bool) -> Eq FieldCascade
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldCascade -> FieldCascade -> Bool
== :: FieldCascade -> FieldCascade -> Bool
$c/= :: FieldCascade -> FieldCascade -> Bool
/= :: FieldCascade -> FieldCascade -> Bool
Eq, ReadPrec [FieldCascade]
ReadPrec FieldCascade
Int -> ReadS FieldCascade
ReadS [FieldCascade]
(Int -> ReadS FieldCascade)
-> ReadS [FieldCascade]
-> ReadPrec FieldCascade
-> ReadPrec [FieldCascade]
-> Read FieldCascade
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldCascade
readsPrec :: Int -> ReadS FieldCascade
$creadList :: ReadS [FieldCascade]
readList :: ReadS [FieldCascade]
$creadPrec :: ReadPrec FieldCascade
readPrec :: ReadPrec FieldCascade
$creadListPrec :: ReadPrec [FieldCascade]
readListPrec :: ReadPrec [FieldCascade]
Read, Eq FieldCascade
Eq FieldCascade =>
(FieldCascade -> FieldCascade -> Ordering)
-> (FieldCascade -> FieldCascade -> Bool)
-> (FieldCascade -> FieldCascade -> Bool)
-> (FieldCascade -> FieldCascade -> Bool)
-> (FieldCascade -> FieldCascade -> Bool)
-> (FieldCascade -> FieldCascade -> FieldCascade)
-> (FieldCascade -> FieldCascade -> FieldCascade)
-> Ord FieldCascade
FieldCascade -> FieldCascade -> Bool
FieldCascade -> FieldCascade -> Ordering
FieldCascade -> FieldCascade -> FieldCascade
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldCascade -> FieldCascade -> Ordering
compare :: FieldCascade -> FieldCascade -> Ordering
$c< :: FieldCascade -> FieldCascade -> Bool
< :: FieldCascade -> FieldCascade -> Bool
$c<= :: FieldCascade -> FieldCascade -> Bool
<= :: FieldCascade -> FieldCascade -> Bool
$c> :: FieldCascade -> FieldCascade -> Bool
> :: FieldCascade -> FieldCascade -> Bool
$c>= :: FieldCascade -> FieldCascade -> Bool
>= :: FieldCascade -> FieldCascade -> Bool
$cmax :: FieldCascade -> FieldCascade -> FieldCascade
max :: FieldCascade -> FieldCascade -> FieldCascade
$cmin :: FieldCascade -> FieldCascade -> FieldCascade
min :: FieldCascade -> FieldCascade -> FieldCascade
Ord, (forall (m :: * -> *). Quote m => FieldCascade -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    FieldCascade -> Code m FieldCascade)
-> Lift FieldCascade
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldCascade -> m Exp
forall (m :: * -> *).
Quote m =>
FieldCascade -> Code m FieldCascade
$clift :: forall (m :: * -> *). Quote m => FieldCascade -> m Exp
lift :: forall (m :: * -> *). Quote m => FieldCascade -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
FieldCascade -> Code m FieldCascade
liftTyped :: forall (m :: * -> *).
Quote m =>
FieldCascade -> Code m FieldCascade
Lift)

-- | A 'FieldCascade' that does nothing.
--
-- @since 2.11.0
noCascade :: FieldCascade
noCascade :: FieldCascade
noCascade = Maybe CascadeAction -> Maybe CascadeAction -> FieldCascade
FieldCascade Maybe CascadeAction
forall a. Maybe a
Nothing Maybe CascadeAction
forall a. Maybe a
Nothing

-- | Renders a 'FieldCascade' value such that it can be used in SQL
-- migrations.
--
-- @since 2.11.0
renderFieldCascade :: FieldCascade -> Text
renderFieldCascade :: FieldCascade -> Text
renderFieldCascade (FieldCascade Maybe CascadeAction
onUpdate Maybe CascadeAction
onDelete) =
    [Text] -> Text
T.unwords
        [ (CascadeAction -> Text) -> Maybe CascadeAction -> Text
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Text -> Text -> Text
forall a. Monoid a => a -> a -> a
mappend Text
" ON DELETE " (Text -> Text) -> (CascadeAction -> Text) -> CascadeAction -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CascadeAction -> Text
renderCascadeAction) Maybe CascadeAction
onDelete
        , (CascadeAction -> Text) -> Maybe CascadeAction -> Text
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Text -> Text -> Text
forall a. Monoid a => a -> a -> a
mappend Text
" ON UPDATE " (Text -> Text) -> (CascadeAction -> Text) -> CascadeAction -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CascadeAction -> Text
renderCascadeAction) Maybe CascadeAction
onUpdate
        ]

-- | An action that might happen on a deletion or update on a foreign key
-- change.
--
-- @since 2.11.0
data CascadeAction = Cascade | Restrict | SetNull | SetDefault
    deriving (Int -> CascadeAction -> ShowS
[CascadeAction] -> ShowS
CascadeAction -> [Char]
(Int -> CascadeAction -> ShowS)
-> (CascadeAction -> [Char])
-> ([CascadeAction] -> ShowS)
-> Show CascadeAction
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CascadeAction -> ShowS
showsPrec :: Int -> CascadeAction -> ShowS
$cshow :: CascadeAction -> [Char]
show :: CascadeAction -> [Char]
$cshowList :: [CascadeAction] -> ShowS
showList :: [CascadeAction] -> ShowS
Show, CascadeAction -> CascadeAction -> Bool
(CascadeAction -> CascadeAction -> Bool)
-> (CascadeAction -> CascadeAction -> Bool) -> Eq CascadeAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CascadeAction -> CascadeAction -> Bool
== :: CascadeAction -> CascadeAction -> Bool
$c/= :: CascadeAction -> CascadeAction -> Bool
/= :: CascadeAction -> CascadeAction -> Bool
Eq, ReadPrec [CascadeAction]
ReadPrec CascadeAction
Int -> ReadS CascadeAction
ReadS [CascadeAction]
(Int -> ReadS CascadeAction)
-> ReadS [CascadeAction]
-> ReadPrec CascadeAction
-> ReadPrec [CascadeAction]
-> Read CascadeAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CascadeAction
readsPrec :: Int -> ReadS CascadeAction
$creadList :: ReadS [CascadeAction]
readList :: ReadS [CascadeAction]
$creadPrec :: ReadPrec CascadeAction
readPrec :: ReadPrec CascadeAction
$creadListPrec :: ReadPrec [CascadeAction]
readListPrec :: ReadPrec [CascadeAction]
Read, Eq CascadeAction
Eq CascadeAction =>
(CascadeAction -> CascadeAction -> Ordering)
-> (CascadeAction -> CascadeAction -> Bool)
-> (CascadeAction -> CascadeAction -> Bool)
-> (CascadeAction -> CascadeAction -> Bool)
-> (CascadeAction -> CascadeAction -> Bool)
-> (CascadeAction -> CascadeAction -> CascadeAction)
-> (CascadeAction -> CascadeAction -> CascadeAction)
-> Ord CascadeAction
CascadeAction -> CascadeAction -> Bool
CascadeAction -> CascadeAction -> Ordering
CascadeAction -> CascadeAction -> CascadeAction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CascadeAction -> CascadeAction -> Ordering
compare :: CascadeAction -> CascadeAction -> Ordering
$c< :: CascadeAction -> CascadeAction -> Bool
< :: CascadeAction -> CascadeAction -> Bool
$c<= :: CascadeAction -> CascadeAction -> Bool
<= :: CascadeAction -> CascadeAction -> Bool
$c> :: CascadeAction -> CascadeAction -> Bool
> :: CascadeAction -> CascadeAction -> Bool
$c>= :: CascadeAction -> CascadeAction -> Bool
>= :: CascadeAction -> CascadeAction -> Bool
$cmax :: CascadeAction -> CascadeAction -> CascadeAction
max :: CascadeAction -> CascadeAction -> CascadeAction
$cmin :: CascadeAction -> CascadeAction -> CascadeAction
min :: CascadeAction -> CascadeAction -> CascadeAction
Ord, (forall (m :: * -> *). Quote m => CascadeAction -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    CascadeAction -> Code m CascadeAction)
-> Lift CascadeAction
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => CascadeAction -> m Exp
forall (m :: * -> *).
Quote m =>
CascadeAction -> Code m CascadeAction
$clift :: forall (m :: * -> *). Quote m => CascadeAction -> m Exp
lift :: forall (m :: * -> *). Quote m => CascadeAction -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
CascadeAction -> Code m CascadeAction
liftTyped :: forall (m :: * -> *).
Quote m =>
CascadeAction -> Code m CascadeAction
Lift)

-- | Render a 'CascadeAction' to 'Text' such that it can be used in a SQL
-- command.
--
-- @since 2.11.0
renderCascadeAction :: CascadeAction -> Text
renderCascadeAction :: CascadeAction -> Text
renderCascadeAction CascadeAction
action = case CascadeAction
action of
  CascadeAction
Cascade    -> Text
"CASCADE"
  CascadeAction
Restrict   -> Text
"RESTRICT"
  CascadeAction
SetNull    -> Text
"SET NULL"
  CascadeAction
SetDefault -> Text
"SET DEFAULT"

data PersistException
  = PersistError Text -- ^ Generic Exception
  | PersistMarshalError Text
  | PersistInvalidField Text
  | PersistForeignConstraintUnmet Text
  | PersistMongoDBError Text
  | PersistMongoDBUnsupported Text
    deriving Int -> PersistException -> ShowS
[PersistException] -> ShowS
PersistException -> [Char]
(Int -> PersistException -> ShowS)
-> (PersistException -> [Char])
-> ([PersistException] -> ShowS)
-> Show PersistException
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PersistException -> ShowS
showsPrec :: Int -> PersistException -> ShowS
$cshow :: PersistException -> [Char]
show :: PersistException -> [Char]
$cshowList :: [PersistException] -> ShowS
showList :: [PersistException] -> ShowS
Show

instance Exception PersistException

-- | A SQL data type. Naming attempts to reflect the underlying Haskell
-- datatypes, eg SqlString instead of SqlVarchar. Different SQL databases may
-- have different translations for these types.
data SqlType = SqlString
             | SqlInt32
             | SqlInt64
             | SqlReal
             | SqlNumeric Word32 Word32
             | SqlBool
             | SqlDay
             | SqlTime
             | SqlDayTime -- ^ Always uses UTC timezone
             | SqlBlob
             | SqlOther T.Text -- ^ a backend-specific name
    deriving (Int -> SqlType -> ShowS
[SqlType] -> ShowS
SqlType -> [Char]
(Int -> SqlType -> ShowS)
-> (SqlType -> [Char]) -> ([SqlType] -> ShowS) -> Show SqlType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SqlType -> ShowS
showsPrec :: Int -> SqlType -> ShowS
$cshow :: SqlType -> [Char]
show :: SqlType -> [Char]
$cshowList :: [SqlType] -> ShowS
showList :: [SqlType] -> ShowS
Show, ReadPrec [SqlType]
ReadPrec SqlType
Int -> ReadS SqlType
ReadS [SqlType]
(Int -> ReadS SqlType)
-> ReadS [SqlType]
-> ReadPrec SqlType
-> ReadPrec [SqlType]
-> Read SqlType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SqlType
readsPrec :: Int -> ReadS SqlType
$creadList :: ReadS [SqlType]
readList :: ReadS [SqlType]
$creadPrec :: ReadPrec SqlType
readPrec :: ReadPrec SqlType
$creadListPrec :: ReadPrec [SqlType]
readListPrec :: ReadPrec [SqlType]
Read, SqlType -> SqlType -> Bool
(SqlType -> SqlType -> Bool)
-> (SqlType -> SqlType -> Bool) -> Eq SqlType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqlType -> SqlType -> Bool
== :: SqlType -> SqlType -> Bool
$c/= :: SqlType -> SqlType -> Bool
/= :: SqlType -> SqlType -> Bool
Eq, Eq SqlType
Eq SqlType =>
(SqlType -> SqlType -> Ordering)
-> (SqlType -> SqlType -> Bool)
-> (SqlType -> SqlType -> Bool)
-> (SqlType -> SqlType -> Bool)
-> (SqlType -> SqlType -> Bool)
-> (SqlType -> SqlType -> SqlType)
-> (SqlType -> SqlType -> SqlType)
-> Ord SqlType
SqlType -> SqlType -> Bool
SqlType -> SqlType -> Ordering
SqlType -> SqlType -> SqlType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SqlType -> SqlType -> Ordering
compare :: SqlType -> SqlType -> Ordering
$c< :: SqlType -> SqlType -> Bool
< :: SqlType -> SqlType -> Bool
$c<= :: SqlType -> SqlType -> Bool
<= :: SqlType -> SqlType -> Bool
$c> :: SqlType -> SqlType -> Bool
> :: SqlType -> SqlType -> Bool
$c>= :: SqlType -> SqlType -> Bool
>= :: SqlType -> SqlType -> Bool
$cmax :: SqlType -> SqlType -> SqlType
max :: SqlType -> SqlType -> SqlType
$cmin :: SqlType -> SqlType -> SqlType
min :: SqlType -> SqlType -> SqlType
Ord, (forall (m :: * -> *). Quote m => SqlType -> m Exp)
-> (forall (m :: * -> *). Quote m => SqlType -> Code m SqlType)
-> Lift SqlType
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SqlType -> m Exp
forall (m :: * -> *). Quote m => SqlType -> Code m SqlType
$clift :: forall (m :: * -> *). Quote m => SqlType -> m Exp
lift :: forall (m :: * -> *). Quote m => SqlType -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => SqlType -> Code m SqlType
liftTyped :: forall (m :: * -> *). Quote m => SqlType -> Code m SqlType
Lift)

data PersistFilter = Eq | Ne | Gt | Lt | Ge | Le | In | NotIn
                   | BackendSpecificFilter T.Text
    deriving (ReadPrec [PersistFilter]
ReadPrec PersistFilter
Int -> ReadS PersistFilter
ReadS [PersistFilter]
(Int -> ReadS PersistFilter)
-> ReadS [PersistFilter]
-> ReadPrec PersistFilter
-> ReadPrec [PersistFilter]
-> Read PersistFilter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PersistFilter
readsPrec :: Int -> ReadS PersistFilter
$creadList :: ReadS [PersistFilter]
readList :: ReadS [PersistFilter]
$creadPrec :: ReadPrec PersistFilter
readPrec :: ReadPrec PersistFilter
$creadListPrec :: ReadPrec [PersistFilter]
readListPrec :: ReadPrec [PersistFilter]
Read, Int -> PersistFilter -> ShowS
[PersistFilter] -> ShowS
PersistFilter -> [Char]
(Int -> PersistFilter -> ShowS)
-> (PersistFilter -> [Char])
-> ([PersistFilter] -> ShowS)
-> Show PersistFilter
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PersistFilter -> ShowS
showsPrec :: Int -> PersistFilter -> ShowS
$cshow :: PersistFilter -> [Char]
show :: PersistFilter -> [Char]
$cshowList :: [PersistFilter] -> ShowS
showList :: [PersistFilter] -> ShowS
Show, (forall (m :: * -> *). Quote m => PersistFilter -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    PersistFilter -> Code m PersistFilter)
-> Lift PersistFilter
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PersistFilter -> m Exp
forall (m :: * -> *).
Quote m =>
PersistFilter -> Code m PersistFilter
$clift :: forall (m :: * -> *). Quote m => PersistFilter -> m Exp
lift :: forall (m :: * -> *). Quote m => PersistFilter -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
PersistFilter -> Code m PersistFilter
liftTyped :: forall (m :: * -> *).
Quote m =>
PersistFilter -> Code m PersistFilter
Lift)

data UpdateException = KeyNotFound String
                     | UpsertError String
instance Show UpdateException where
    show :: UpdateException -> [Char]
show (KeyNotFound [Char]
key) = [Char]
"Key not found during updateGet: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
key
    show (UpsertError [Char]
msg) = [Char]
"Error during upsert: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg
instance Exception UpdateException

data OnlyUniqueException = OnlyUniqueException String
instance Show OnlyUniqueException where
    show :: OnlyUniqueException -> [Char]
show (OnlyUniqueException [Char]
uniqueMsg) =
      [Char]
"Expected only one unique key, got " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
uniqueMsg
instance Exception OnlyUniqueException


data PersistUpdate
    = Assign | Add | Subtract | Multiply | Divide
    | BackendSpecificUpdate T.Text
    deriving (ReadPrec [PersistUpdate]
ReadPrec PersistUpdate
Int -> ReadS PersistUpdate
ReadS [PersistUpdate]
(Int -> ReadS PersistUpdate)
-> ReadS [PersistUpdate]
-> ReadPrec PersistUpdate
-> ReadPrec [PersistUpdate]
-> Read PersistUpdate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PersistUpdate
readsPrec :: Int -> ReadS PersistUpdate
$creadList :: ReadS [PersistUpdate]
readList :: ReadS [PersistUpdate]
$creadPrec :: ReadPrec PersistUpdate
readPrec :: ReadPrec PersistUpdate
$creadListPrec :: ReadPrec [PersistUpdate]
readListPrec :: ReadPrec [PersistUpdate]
Read, Int -> PersistUpdate -> ShowS
[PersistUpdate] -> ShowS
PersistUpdate -> [Char]
(Int -> PersistUpdate -> ShowS)
-> (PersistUpdate -> [Char])
-> ([PersistUpdate] -> ShowS)
-> Show PersistUpdate
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PersistUpdate -> ShowS
showsPrec :: Int -> PersistUpdate -> ShowS
$cshow :: PersistUpdate -> [Char]
show :: PersistUpdate -> [Char]
$cshowList :: [PersistUpdate] -> ShowS
showList :: [PersistUpdate] -> ShowS
Show, (forall (m :: * -> *). Quote m => PersistUpdate -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    PersistUpdate -> Code m PersistUpdate)
-> Lift PersistUpdate
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PersistUpdate -> m Exp
forall (m :: * -> *).
Quote m =>
PersistUpdate -> Code m PersistUpdate
$clift :: forall (m :: * -> *). Quote m => PersistUpdate -> m Exp
lift :: forall (m :: * -> *). Quote m => PersistUpdate -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
PersistUpdate -> Code m PersistUpdate
liftTyped :: forall (m :: * -> *).
Quote m =>
PersistUpdate -> Code m PersistUpdate
Lift)

-- | 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.
data FieldDef = FieldDef
    { FieldDef -> FieldNameHS
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@.
    , FieldDef -> FieldNameDB
fieldDB        :: !FieldNameDB
    -- ^ The name of the field in the database. For SQL databases, this
    -- corresponds to the column name.
    , FieldDef -> FieldType
fieldType      :: !FieldType
    -- ^ The type of the field in Haskell.
    , FieldDef -> SqlType
fieldSqlType   :: !SqlType
    -- ^ The type of the field in a SQL database.
    , FieldDef -> [FieldAttr]
fieldAttrs     :: ![FieldAttr]
    -- ^ User annotations for a field. These are provided with the @!@
    -- operator.
    , FieldDef -> Bool
fieldStrict    :: !Bool
    -- ^ If this is 'True', then the Haskell datatype will have a strict
    -- record field. The default value for this is 'True'.
    , FieldDef -> ReferenceDef
fieldReference :: !ReferenceDef
    , FieldDef -> FieldCascade
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
    , FieldDef -> Maybe Text
fieldComments  :: !(Maybe Text)
    -- ^ Optional comments for a 'Field'.
    --
    -- @since 2.10.0
    , FieldDef -> Maybe Text
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
    , FieldDef -> Bool
fieldIsImplicitIdColumn :: !Bool
    -- ^ 'True' if the field is an implicit ID column. 'False' otherwise.
    --
    -- @since 2.13.0.0
    }
    deriving (Int -> FieldDef -> ShowS
[FieldDef] -> ShowS
FieldDef -> [Char]
(Int -> FieldDef -> ShowS)
-> (FieldDef -> [Char]) -> ([FieldDef] -> ShowS) -> Show FieldDef
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldDef -> ShowS
showsPrec :: Int -> FieldDef -> ShowS
$cshow :: FieldDef -> [Char]
show :: FieldDef -> [Char]
$cshowList :: [FieldDef] -> ShowS
showList :: [FieldDef] -> ShowS
Show, FieldDef -> FieldDef -> Bool
(FieldDef -> FieldDef -> Bool)
-> (FieldDef -> FieldDef -> Bool) -> Eq FieldDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldDef -> FieldDef -> Bool
== :: FieldDef -> FieldDef -> Bool
$c/= :: FieldDef -> FieldDef -> Bool
/= :: FieldDef -> FieldDef -> Bool
Eq, ReadPrec [FieldDef]
ReadPrec FieldDef
Int -> ReadS FieldDef
ReadS [FieldDef]
(Int -> ReadS FieldDef)
-> ReadS [FieldDef]
-> ReadPrec FieldDef
-> ReadPrec [FieldDef]
-> Read FieldDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldDef
readsPrec :: Int -> ReadS FieldDef
$creadList :: ReadS [FieldDef]
readList :: ReadS [FieldDef]
$creadPrec :: ReadPrec FieldDef
readPrec :: ReadPrec FieldDef
$creadListPrec :: ReadPrec [FieldDef]
readListPrec :: ReadPrec [FieldDef]
Read, Eq FieldDef
Eq FieldDef =>
(FieldDef -> FieldDef -> Ordering)
-> (FieldDef -> FieldDef -> Bool)
-> (FieldDef -> FieldDef -> Bool)
-> (FieldDef -> FieldDef -> Bool)
-> (FieldDef -> FieldDef -> Bool)
-> (FieldDef -> FieldDef -> FieldDef)
-> (FieldDef -> FieldDef -> FieldDef)
-> Ord FieldDef
FieldDef -> FieldDef -> Bool
FieldDef -> FieldDef -> Ordering
FieldDef -> FieldDef -> FieldDef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldDef -> FieldDef -> Ordering
compare :: FieldDef -> FieldDef -> Ordering
$c< :: FieldDef -> FieldDef -> Bool
< :: FieldDef -> FieldDef -> Bool
$c<= :: FieldDef -> FieldDef -> Bool
<= :: FieldDef -> FieldDef -> Bool
$c> :: FieldDef -> FieldDef -> Bool
> :: FieldDef -> FieldDef -> Bool
$c>= :: FieldDef -> FieldDef -> Bool
>= :: FieldDef -> FieldDef -> Bool
$cmax :: FieldDef -> FieldDef -> FieldDef
max :: FieldDef -> FieldDef -> FieldDef
$cmin :: FieldDef -> FieldDef -> FieldDef
min :: FieldDef -> FieldDef -> FieldDef
Ord, (forall (m :: * -> *). Quote m => FieldDef -> m Exp)
-> (forall (m :: * -> *). Quote m => FieldDef -> Code m FieldDef)
-> Lift FieldDef
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldDef -> m Exp
forall (m :: * -> *). Quote m => FieldDef -> Code m FieldDef
$clift :: forall (m :: * -> *). Quote m => FieldDef -> m Exp
lift :: forall (m :: * -> *). Quote m => FieldDef -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => FieldDef -> Code m FieldDef
liftTyped :: forall (m :: * -> *). Quote m => FieldDef -> Code m FieldDef
Lift)