{-# LANGUAGE GADTs     #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE AllowAmbiguousTypes #-}


module Database.GP.RecordtypeReflection
  ( 
    fieldValue,
    gFromRow,
    gToRow,
  )
where

import           Control.Monad                  (zipWithM)
import           Control.Monad.Trans.Class      (lift)
import           Control.Monad.Trans.State.Lazy (StateT (..))
import qualified Data.ByteString                as B
import           Data.Data                      hiding (typeRep)
import           Data.Dynamic                   (Dynamic, fromDynamic, toDyn)
import           Data.Int                       (Int32, Int64)
import           Data.List                      (elemIndex, uncons)
import           Data.Ratio                     (Ratio)
import qualified Data.Text                      as TS
import qualified Data.Text.Lazy                 as TL
import           Data.Time                      (Day, LocalTime,
                                                 NominalDiffTime, TimeOfDay,
                                                 UTCTime, ZonedTime)
import           Data.Time.Clock.POSIX          (POSIXTime)
import           Data.Word                      (Word32, Word64)
import           Database.HDBC                  (SqlValue, fromSql, toSql)
import           GHC.Data.Maybe                 (expectJust)
import           Type.Reflection                (SomeTypeRep (..), eqTypeRep,
                                                 typeRep)
import           Database.GP.TypeInfo

-- | A function that takes an entity and a field name as input parameters and returns the value of the field as a String.
--  Example: fieldValue (Person "John" 42) "name" = SqlString "John"
--  Example: fieldValue (Person "John" 42) "age" = SqlInt64 42
--  if the field is not present in the entity, an error is thrown.
fieldValue :: Data a => a -> String -> SqlValue
fieldValue :: forall a. Data a => a -> String -> SqlValue
fieldValue a
x String
field =
  SomeTypeRep -> Dynamic -> SqlValue
convertToSqlValue SomeTypeRep
fieldType ([Dynamic]
valueList forall a. [a] -> Int -> a
!! Int
index)
  where
    ti :: TypeInfo a
ti = forall a. Data a => a -> TypeInfo a
typeInfo a
x
    fieldList :: [String]
fieldList = forall {k} (a :: k). TypeInfo a -> [String]
fieldNames TypeInfo a
ti
    valueList :: [Dynamic]
valueList = forall a. Data a => a -> [Dynamic]
fieldValues a
x
    index :: Int
index =
      forall a. HasCallStack => String -> Maybe a -> a
expectJust
        (String
"Field " forall a. [a] -> [a] -> [a]
++ String
field forall a. [a] -> [a] -> [a]
++ String
" is not present in type " forall a. [a] -> [a] -> [a]
++ forall {k} (a :: k). TypeInfo a -> String
typeName TypeInfo a
ti)
        (forall a. Eq a => a -> [a] -> Maybe Int
elemIndex String
field [String]
fieldList)
    fieldType :: SomeTypeRep
fieldType = forall {k} (a :: k). TypeInfo a -> [SomeTypeRep]
fieldTypes TypeInfo a
ti forall a. [a] -> Int -> a
!! Int
index

fieldValues :: (Data a) => a -> [Dynamic]
fieldValues :: forall a. Data a => a -> [Dynamic]
fieldValues = forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
gmapQ forall a. Typeable a => a -> Dynamic
toDyn

gFromRow :: forall a. (Data a) => [SqlValue] -> a
gFromRow :: forall a. Data a => [SqlValue] -> a
gFromRow [SqlValue]
row = forall a. HasCallStack => String -> Maybe a -> a
expectJust String
errMsg (forall a. Data a => TypeInfo a -> [SqlValue] -> Maybe a
buildFromRecord TypeInfo a
ti [SqlValue]
row)
  where
    ti :: TypeInfo a
ti = forall a. Data a => TypeInfo a
typeInfoFromContext
    tName :: String
tName = forall {k} (a :: k). TypeInfo a -> String
typeName TypeInfo a
ti
    errMsg :: String
errMsg = String
"can't construct an " forall a. [a] -> [a] -> [a]
++ String
tName forall a. [a] -> [a] -> [a]
++ String
" instance from " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [SqlValue]
row

gToRow :: (Data a) => a -> [SqlValue]
gToRow :: forall a. Data a => a -> [SqlValue]
gToRow a
x = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith SomeTypeRep -> Dynamic -> SqlValue
convertToSqlValue [SomeTypeRep]
types [Dynamic]
values
  where
    ti :: TypeInfo a
ti = forall a. Data a => a -> TypeInfo a
typeInfo a
x
    types :: [SomeTypeRep]
types = forall {k} (a :: k). TypeInfo a -> [SomeTypeRep]
fieldTypes TypeInfo a
ti
    values :: [Dynamic]
values = forall a. Data a => a -> [Dynamic]
fieldValues a
x

-- | This function takes a `TypeInfo a`and a List of HDBC `SqlValue`s and returns a `Maybe a`.
--  If the conversion fails, Nothing is returned, otherwise Just a.
buildFromRecord :: (Data a) => TypeInfo a -> [SqlValue] -> Maybe a
buildFromRecord :: forall a. Data a => TypeInfo a -> [SqlValue] -> Maybe a
buildFromRecord TypeInfo a
ti [SqlValue]
record = forall a. Data a => Constr -> [Dynamic] -> Maybe a
applyConstr Constr
ctor [Dynamic]
dynamicsArgs
  where
    ctor :: Constr
ctor = forall {k} (a :: k). TypeInfo a -> Constr
typeConstructor TypeInfo a
ti
    types :: [SomeTypeRep]
types = forall {k} (a :: k). TypeInfo a -> [SomeTypeRep]
fieldTypes TypeInfo a
ti
    dynamicsArgs :: [Dynamic]
dynamicsArgs =
      forall a. HasCallStack => String -> Maybe a -> a
expectJust
        (String
"buildFromRecord: error in converting record " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [SqlValue]
record)
        (forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM SomeTypeRep -> SqlValue -> Maybe Dynamic
convertToDynamic [SomeTypeRep]
types [SqlValue]
record)

-- | This function takes a `Constr` and a list of `Dynamic` values and returns a `Maybe a`.
--   If an `a`entity could be constructed, Just a is returned, otherwise Nothing.
--   See also https://stackoverflow.com/questions/47606189/fromconstrb-or-something-other-useful
--   for Info on how to use fromConstrM
applyConstr :: Data a => Constr -> [Dynamic] -> Maybe a
applyConstr :: forall a. Data a => Constr -> [Dynamic] -> Maybe a
applyConstr Constr
ctor [Dynamic]
args =
  let nextField :: forall d. Data d => StateT [Dynamic] Maybe d
      nextField :: forall d. Data d => StateT [Dynamic] Maybe d
nextField = forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT forall a. [a] -> Maybe (a, [a])
uncons forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Typeable a => Dynamic -> Maybe a
fromDynamic
   in case forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (forall (m :: * -> *) a.
(Monad m, Data a) =>
(forall d. Data d => m d) -> Constr -> m a
fromConstrM forall d. Data d => StateT [Dynamic] Maybe d
nextField Constr
ctor) [Dynamic]
args of
        Just (a
x, []) -> forall a. a -> Maybe a
Just a
x
        Maybe (a, [Dynamic])
_            -> forall a. Maybe a
Nothing -- runtime type error or too few / too many arguments

-- | convert a SqlValue into a Dynamic value that is backed by a value of the type represented by the SomeTypeRep parameter.
--  If conversion fails, return Nothing.
--  conversion to Dynamic is required to allow the use of fromDynamic in applyConstr
--  see also https://stackoverflow.com/questions/46992740/how-to-specify-type-of-value-via-typerep
convertToDynamic :: SomeTypeRep -> SqlValue -> Maybe Dynamic
convertToDynamic :: SomeTypeRep -> SqlValue -> Maybe Dynamic
convertToDynamic (SomeTypeRep TypeRep a
rep) SqlValue
val
  | Just a :~~: Int
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Int)
  | Just a :~~: Double
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Double) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Double)
  | Just a :~~: String
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @String) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: String)
  | Just a :~~: Char
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Char) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Char)
  | Just a :~~: ByteString
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @B.ByteString) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: B.ByteString)
  | Just a :~~: Word32
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Word32) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Word32)
  | Just a :~~: Word64
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Word64) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Word64)
  | Just a :~~: Int32
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int32) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Int32)
  | Just a :~~: Int64
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int64) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Int64)
  | Just a :~~: Integer
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Integer)
  | Just a :~~: Bool
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Bool) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Bool)
  | Just a :~~: UTCTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @UTCTime) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: UTCTime)
  | Just a :~~: POSIXTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @POSIXTime) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: POSIXTime)
  | Just a :~~: LocalTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @LocalTime) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: LocalTime)
  | Just a :~~: ZonedTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @ZonedTime) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: ZonedTime)
  | Just a :~~: TimeOfDay
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TimeOfDay) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: TimeOfDay)
  | Just a :~~: Day
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Day) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Day)
  | Just a :~~: POSIXTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @NominalDiffTime) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: NominalDiffTime)
  | Just a :~~: Ratio
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Ratio) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: Ratio Integer)
  | Just a :~~: Text
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TL.Text) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: TL.Text)
  | Just a :~~: Text
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TS.Text) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => a -> Dynamic
toDyn (forall a. Convertible SqlValue a => SqlValue -> a
fromSql SqlValue
val :: TS.Text)
  | Bool
otherwise = forall a. Maybe a
Nothing

convertToSqlValue :: SomeTypeRep -> Dynamic -> SqlValue
convertToSqlValue :: SomeTypeRep -> Dynamic -> SqlValue
convertToSqlValue (SomeTypeRep TypeRep a
rep) Dynamic
dyn
  | Just a :~~: Int
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not an Int: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Int)
  | Just a :~~: Double
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Double) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Double: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Double)
  | Just a :~~: String
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @String) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a String: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: String)
  | Just a :~~: Char
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Char) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Char: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Char)
  | Just a :~~: ByteString
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @B.ByteString) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a ByteString: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: B.ByteString)
  | Just a :~~: Word32
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Word32) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Word32: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Word32)
  | Just a :~~: Word64
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Word64) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Word64: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Word64)
  | Just a :~~: Int32
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int32) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not an Int32: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Int32)
  | Just a :~~: Int64
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int64) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not an Int64: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Int64)
  | Just a :~~: Integer
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not an Integer: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Integer)
  | Just a :~~: Bool
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Bool) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Bool: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Bool)
  | Just a :~~: UTCTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @UTCTime) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a UTCTime: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: UTCTime)
  | Just a :~~: POSIXTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @POSIXTime) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a PosixTime: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: POSIXTime)
  | Just a :~~: LocalTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @LocalTime) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a LocalTime: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: LocalTime)
  | Just a :~~: ZonedTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @ZonedTime) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a ZonedTime: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: ZonedTime)
  | Just a :~~: TimeOfDay
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TimeOfDay) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a TimeOfDay: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: TimeOfDay)
  | Just a :~~: Day
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Day) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Day: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Day)
  | Just a :~~: POSIXTime
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @NominalDiffTime) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a NominalTimeDiff: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: NominalDiffTime)
  | Just a :~~: Ratio
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Ratio) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a Ratio: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: Ratio Integer)
  | Just a :~~: Text
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TL.Text) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a TL.Text: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: TL.Text)
  | Just a :~~: Text
HRefl <- forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
rep (forall {k} (a :: k). Typeable a => TypeRep a
typeRep @TS.Text) = forall a. Convertible a SqlValue => a -> SqlValue
toSql (forall a. HasCallStack => String -> Maybe a -> a
expectJust (String
"Not a TS.Text: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Dynamic
dyn) (forall a. Typeable a => Dynamic -> Maybe a
fromDynamic Dynamic
dyn) :: TS.Text)
  | Bool
otherwise = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"convertToSqlValue: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show TypeRep a
rep forall a. [a] -> [a] -> [a]
++ String
" not supported"