{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE StandaloneDeriving #-}
module Database.HDBC.SqlValue
    (
     -- * SQL value marshalling
     SqlValue(..),
     safeFromSql, toSql, fromSql,
     nToSql, iToSql, posixToSql
    )

where
import Data.Dynamic
import qualified Data.ByteString.UTF8 as BUTF8
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BSL
import Data.Char(ord,toUpper)
import Data.Word
import Data.Int
import qualified System.Time as ST
import Data.Time ( Day (ModifiedJulianDay), DiffTime, LocalTime, NominalDiffTime, ParseTime
                 , TimeOfDay, TimeZone, UTCTime, ZonedTime, formatTime, localDay, localTimeOfDay
                 , timeOfDayToTime, timeToTimeOfDay, toModifiedJulianDay, utc
                 , utcToZonedTime, zonedTimeToLocalTime, zonedTimeToUTC, zonedTimeZone
#if MIN_TIME_15
                 , parseTimeM
#else
                 , parseTime
#endif
                 )
import Data.Time.Clock.POSIX
import Database.HDBC.Locale (defaultTimeLocale, iso8601DateFormat)
import Data.Ratio
import Data.Convertible
import Data.Fixed
import qualified Data.Text as TS
import qualified Data.Text.Lazy as TL

quickError :: (Typeable a, Convertible SqlValue a) => SqlValue -> ConvertResult a
quickError :: SqlValue -> ConvertResult a
quickError sv :: SqlValue
sv = String -> SqlValue -> ConvertResult a
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "incompatible types" SqlValue
sv
  
{- | Convert a value to an 'SqlValue'.  This function is simply
a restricted-type wrapper around 'convert'.  See extended notes on 'SqlValue'. -}
toSql :: Convertible a SqlValue => a -> SqlValue
toSql :: a -> SqlValue
toSql = a -> SqlValue
forall a b. Convertible a b => a -> b
convert

{- | Conversions to and from 'SqlValue's and standard Haskell types.

This function converts from an 'SqlValue' to a Haskell value.  Many people will use the simpler
   'fromSql' instead.  This function is simply a restricted-type wrapper around
   'safeConvert'. -}
safeFromSql :: Convertible SqlValue a => SqlValue -> ConvertResult a
safeFromSql :: SqlValue -> ConvertResult a
safeFromSql = SqlValue -> ConvertResult a
forall a b. Convertible a b => a -> ConvertResult b
safeConvert

{- | Convert from an 'SqlValue' to a Haskell value.  Any problem is indicated by
   calling 'error'.  This function is simply a restricted-type wrapper around
   'convert'.  See extended notes on 'SqlValue'. -}
fromSql :: Convertible SqlValue a => SqlValue -> a
fromSql :: SqlValue -> a
fromSql = SqlValue -> a
forall a b. Convertible a b => a -> b
convert

{- | Converts any Integral type to a 'SqlValue' by using toInteger. -}
nToSql :: Integral a => a -> SqlValue
nToSql :: a -> SqlValue
nToSql n :: a
n = Integer -> SqlValue
SqlInteger (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
n)

{- | Convenience function for using numeric literals in your program. -}
iToSql :: Int -> SqlValue
iToSql :: Int -> SqlValue
iToSql = Int -> SqlValue
forall a. Convertible a SqlValue => a -> SqlValue
toSql

{- | Convenience function for converting 'POSIXTime' to a 'SqlValue', because
'toSql' cannot do the correct thing in this instance. -}
posixToSql :: POSIXTime -> SqlValue
posixToSql :: POSIXTime -> SqlValue
posixToSql x :: POSIXTime
x = POSIXTime -> SqlValue
SqlPOSIXTime POSIXTime
x

{- | 'SqlValue' is the main type for expressing Haskell values to SQL databases.

/INTRODUCTION TO SQLVALUE/

This type is used to marshall Haskell data to and from database APIs.
HDBC driver interfaces will do their best to use the most accurate and
efficient way to send a particular value to the database server.

Values read back from the server are constructed with the most appropriate 'SqlValue'
constructor.  'fromSql' or 'safeFromSql' 
can then be used to convert them into whatever type
is needed locally in Haskell.

Most people will use 'toSql' and 'fromSql' instead of manipulating
'SqlValue's directly.

/EASY CONVERSIONS BETWEEN HASKELL TYPES/

Conversions are powerful; for instance, you can call 'fromSql' on a SqlInt32
and get a String or a Double out of it.  This class attempts to Do
The Right Thing whenever possible, and will raise an error when asked to
do something incorrect.  In particular, when converting to any type
except a Maybe, 'SqlNull' as the input will cause an error to be raised.

Conversions are implemented in terms of the "Data.Convertible" module, part of the
convertible package.  You can refer to its documentation, and import that module,
if you wish to parse the Left result from 'safeFromSql' yourself, or write your
own conversion instances.

Here are some notes about conversion:

 * Fractions of a second are not preserved on time values

 * There is no @safeToSql@ because 'toSql' never fails.

See also 'toSql', 'safeFromSql', 'fromSql', 'nToSql', 'iToSql', 'posixToSql'.

/ERROR CONDITIONS/

There may sometimes be an error during conversion.  For instance, if you have a
'SqlString' and are attempting to convert it to an Integer, but it doesn't parse as
an Integer, you will get an error.  This will be indicated as an exception if using
'fromSql', or a Left result if using 'safeFromSql'.

/SPECIAL NOTE ON POSIXTIME/

Note that a 'NominalDiffTime' or 'POSIXTime' is converted to 'SqlDiffTime' by
'toSql'.  HDBC cannot differentiate between 'NominalDiffTime' and 'POSIXTime'
since they are the same underlying type.  You must construct 'SqlPOSIXTime'
manually or via 'posixToSql', or use 'SqlUTCTime'.

/DETAILS ON SQL TYPES/

HDBC database backends are expected to marshal date and time data back and
forth using the appropriate representation for the underlying database engine.
Databases such as PostgreSQL with builtin date and time types should see automatic
conversion between these Haskell types to database types.  Other databases will be
presented with an integer or a string.  Care should be taken to use the same type on
the Haskell side as you use on the database side.  For instance, if your database
type lacks timezone information, you ought not to use ZonedTime, but
instead LocalTime or UTCTime.  Database type systems are not always as rich
as Haskell.  For instance, for data stored in a TIMESTAMP
WITHOUT TIME ZONE column, HDBC may not be able to tell if it is intended
as UTCTime or LocalTime data, and will happily convert it to both, 
upon your request.  It is
your responsibility to ensure that you treat timezone issues with due care.

This behavior also exists for other types.  For instance, many databases do not
have a Rational type, so they will just use the show function and
store a Rational as a string.

The conversion between Haskell types and database types is complex,
and generic code in HDBC or its backends cannot possibly accomodate
every possible situation.  In some cases, you may be best served by converting your
Haskell type to a String, and passing that to the database.

/UNICODE AND BYTESTRINGS/

Beginning with HDBC v2.0, interactions with a database are presumed to occur in UTF-8.

To accomplish this, whenever a ByteString must be converted to or from a String,
the ByteString is assumed to be in UTF-8 encoding, and will be decoded or encoded
as appropriate.  Database drivers will generally present text or string data they have
received from the database as a SqlValue holding a ByteString, which 'fromSql' will
automatically convert to a String, and thus automatically decode UTF-8, when
you need it.  In the other direction, database drivers will generally convert
a 'SqlString' to a ByteString in UTF-8 encoding before passing it to the
database engine.

If you are handling some sort of binary data that is not in UTF-8, you can of course
work with the ByteString directly, which will bypass any conversion.

Due to lack of support by database engines, lazy ByteStrings are not passed to database
drivers.  When you use 'toSql' on a lazy ByteString, it will be converted to a strict
ByteString for storage.  Similarly, 'fromSql' will convert a strict ByteString to
a lazy ByteString if you demand it.

/EQUALITY OF SQLVALUE/

Two SqlValues are considered to be equal if one of these hold.  The
first comparison that can be made is controlling; if none of these
comparisons can be made, then they are not equal:

 * Both are NULL

 * Both represent the same type and the encapsulated values are considered equal
   by applying (==) to them

 * The values of each, when converted to a string, are equal

/STRING VERSIONS OF TIMES/

Default string representations are given as comments below where such are non-obvious.
These are used for 'fromSql' when a 'String' is desired.  They are also defaults for
representing data to SQL backends, though individual backends may override them
when a different format is demanded by the underlying database.  Date and time formats
use ISO8601 date format, with HH:MM:SS added for time, and -HHMM added for timezone
offsets.

/DEPRECATED CONSTRUCTORS/

'SqlEpochTime' and 'SqlTimeDiff' are no longer created automatically by any
'toSql' or 'fromSql' functions or database backends.  They may still be manually
constructed, but are
expected to be removed in a future version.  Although these two constructures will
be removed, support for marshalling to and from the old System.Time data will be
maintained as long as System.Time is, simply using the newer data types for conversion.
-}
data SqlValue = SqlString String 
              | SqlByteString B.ByteString
              | SqlWord32 Word32
              | SqlWord64 Word64
              | SqlInt32 Int32
              | SqlInt64 Int64
              | SqlInteger Integer
              | SqlChar Char
              | SqlBool Bool
              | SqlDouble Double
              | SqlRational Rational
              | SqlLocalDate Day            -- ^ Local YYYY-MM-DD (no timezone).
              | SqlLocalTimeOfDay TimeOfDay -- ^ Local HH:MM:SS (no timezone).
              | SqlZonedLocalTimeOfDay TimeOfDay TimeZone -- ^ Local HH:MM:SS -HHMM.  Converts to and from (TimeOfDay, TimeZone).
              | SqlLocalTime LocalTime      -- ^ Local YYYY-MM-DD HH:MM:SS (no timezone).
              | SqlZonedTime ZonedTime      -- ^ Local YYYY-MM-DD HH:MM:SS -HHMM.  Considered equal if both convert to the same UTC time.
              | SqlUTCTime UTCTime          -- ^ UTC YYYY-MM-DD HH:MM:SS.
              | SqlDiffTime NominalDiffTime -- ^ Calendar diff between seconds.  Rendered as Integer when converted to String, but greater precision may be preserved for other types or to underlying database.
              | SqlPOSIXTime POSIXTime      -- ^ Time as seconds since midnight Jan 1 1970 UTC.  Integer rendering as for 'SqlDiffTime'.
              | SqlEpochTime Integer      -- ^ DEPRECATED Representation of ClockTime or CalendarTime.  Use SqlPOSIXTime instead.
              | SqlTimeDiff Integer -- ^ DEPRECATED Representation of TimeDiff.  Use SqlDiffTime instead.
              | SqlNull         -- ^ NULL in SQL or Nothing in Haskell.
     deriving (Int -> SqlValue -> ShowS
[SqlValue] -> ShowS
SqlValue -> String
(Int -> SqlValue -> ShowS)
-> (SqlValue -> String) -> ([SqlValue] -> ShowS) -> Show SqlValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SqlValue] -> ShowS
$cshowList :: [SqlValue] -> ShowS
show :: SqlValue -> String
$cshow :: SqlValue -> String
showsPrec :: Int -> SqlValue -> ShowS
$cshowsPrec :: Int -> SqlValue -> ShowS
Show, Typeable)

instance Eq SqlValue where
    SqlString a :: String
a == :: SqlValue -> SqlValue -> Bool
== SqlString b :: String
b = String
a String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
b
    SqlByteString a :: ByteString
a == SqlByteString b :: ByteString
b = ByteString
a ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
b
    SqlWord32 a :: Word32
a == SqlWord32 b :: Word32
b = Word32
a Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
b
    SqlWord64 a :: Word64
a == SqlWord64 b :: Word64
b = Word64
a Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
b
    SqlInt32 a :: Int32
a == SqlInt32 b :: Int32
b = Int32
a Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
b
    SqlInt64 a :: Int64
a == SqlInt64 b :: Int64
b = Int64
a Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
b
    SqlInteger a :: Integer
a == SqlInteger b :: Integer
b = Integer
a Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
b
    SqlChar a :: Char
a == SqlChar b :: Char
b = Char
a Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
b
    SqlBool a :: Bool
a == SqlBool b :: Bool
b = Bool
a Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b
    SqlDouble a :: Double
a == SqlDouble b :: Double
b = Double
a Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
b
    SqlRational a :: Rational
a == SqlRational b :: Rational
b = Rational
a Rational -> Rational -> Bool
forall a. Eq a => a -> a -> Bool
== Rational
b
    SqlLocalTimeOfDay a :: TimeOfDay
a == SqlLocalTimeOfDay b :: TimeOfDay
b = TimeOfDay
a TimeOfDay -> TimeOfDay -> Bool
forall a. Eq a => a -> a -> Bool
== TimeOfDay
b
    SqlZonedLocalTimeOfDay a :: TimeOfDay
a b :: TimeZone
b == SqlZonedLocalTimeOfDay c :: TimeOfDay
c d :: TimeZone
d = TimeOfDay
a TimeOfDay -> TimeOfDay -> Bool
forall a. Eq a => a -> a -> Bool
== TimeOfDay
c Bool -> Bool -> Bool
&& TimeZone
b TimeZone -> TimeZone -> Bool
forall a. Eq a => a -> a -> Bool
== TimeZone
d
    SqlLocalTime a :: LocalTime
a == SqlLocalTime b :: LocalTime
b = LocalTime
a LocalTime -> LocalTime -> Bool
forall a. Eq a => a -> a -> Bool
== LocalTime
b
    SqlLocalDate a :: Day
a == SqlLocalDate b :: Day
b = Day
a Day -> Day -> Bool
forall a. Eq a => a -> a -> Bool
== Day
b
    SqlZonedTime a :: ZonedTime
a == SqlZonedTime b :: ZonedTime
b = ZonedTime -> UTCTime
zonedTimeToUTC ZonedTime
a UTCTime -> UTCTime -> Bool
forall a. Eq a => a -> a -> Bool
== ZonedTime -> UTCTime
zonedTimeToUTC ZonedTime
b
    SqlUTCTime a :: UTCTime
a == SqlUTCTime b :: UTCTime
b = UTCTime
a UTCTime -> UTCTime -> Bool
forall a. Eq a => a -> a -> Bool
== UTCTime
b
    SqlPOSIXTime a :: POSIXTime
a == SqlPOSIXTime b :: POSIXTime
b = POSIXTime
a POSIXTime -> POSIXTime -> Bool
forall a. Eq a => a -> a -> Bool
== POSIXTime
b
    SqlDiffTime a :: POSIXTime
a == SqlDiffTime b :: POSIXTime
b = POSIXTime
a POSIXTime -> POSIXTime -> Bool
forall a. Eq a => a -> a -> Bool
== POSIXTime
b
    SqlEpochTime a :: Integer
a == SqlEpochTime b :: Integer
b = Integer
a Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
b
    SqlTimeDiff a :: Integer
a == SqlTimeDiff b :: Integer
b = Integer
a Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
b
    SqlNull == SqlNull = Bool
True
    SqlNull == _ = Bool
False
    _ == SqlNull = Bool
False
    a :: SqlValue
a == b :: SqlValue
b = ((SqlValue -> ConvertResult String
forall a. Convertible SqlValue a => SqlValue -> ConvertResult a
safeFromSql SqlValue
a)::ConvertResult String) ConvertResult String -> ConvertResult String -> Bool
forall a. Eq a => a -> a -> Bool
== 
             ((SqlValue -> ConvertResult String
forall a. Convertible SqlValue a => SqlValue -> ConvertResult a
safeFromSql SqlValue
b)::ConvertResult String)

deriving instance Typeable ST.ClockTime
deriving instance Typeable ST.TimeDiff

instance Convertible SqlValue SqlValue where
    safeConvert :: SqlValue -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return

instance Convertible String SqlValue where
    safeConvert :: String -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (String -> SqlValue) -> String -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString
instance Convertible SqlValue String where
    safeConvert :: SqlValue -> ConvertResult String
safeConvert (SqlString x :: String
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return String
x
    safeConvert (SqlByteString x :: ByteString
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (ByteString -> String) -> ByteString -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString (ByteString -> ConvertResult String)
-> ByteString -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Int32 -> String) -> Int32 -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> String
forall a. Show a => a -> String
show (Int32 -> ConvertResult String) -> Int32 -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Int64 -> String) -> Int64 -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> String
forall a. Show a => a -> String
show (Int64 -> ConvertResult String) -> Int64 -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Word32 -> String) -> Word32 -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> String
forall a. Show a => a -> String
show (Word32 -> ConvertResult String) -> Word32 -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Word64 -> String) -> Word64 -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> String
forall a. Show a => a -> String
show (Word64 -> ConvertResult String) -> Word64 -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Word64
x
    safeConvert (SqlInteger x :: Integer
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Integer -> String) -> Integer -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> String
forall a. Show a => a -> String
show (Integer -> ConvertResult String)
-> Integer -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert (SqlChar x :: Char
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return [Char
x]
    safeConvert (SqlBool x :: Bool
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Bool -> String) -> Bool -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> String
forall a. Show a => a -> String
show (Bool -> ConvertResult String) -> Bool -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Bool
x
    safeConvert (SqlDouble x :: Double
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Double -> String) -> Double -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> String
forall a. Show a => a -> String
show (Double -> ConvertResult String) -> Double -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Double
x
    safeConvert (SqlRational x :: Rational
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Rational -> String) -> Rational -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> String
forall a. Show a => a -> String
show (Rational -> ConvertResult String)
-> Rational -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Rational
x
    safeConvert (SqlLocalDate x :: Day
x) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Day -> String) -> Day -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> Day -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale (Maybe String -> String
iso8601DateFormat Maybe String
forall a. Maybe a
Nothing) (Day -> ConvertResult String) -> Day -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Day
x
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (TimeOfDay -> String) -> TimeOfDay -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> TimeOfDay -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale "%T%Q" (TimeOfDay -> ConvertResult String)
-> TimeOfDay -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ TimeOfDay
x
    safeConvert (SqlZonedLocalTimeOfDay tod :: TimeOfDay
tod tz :: TimeZone
tz) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String) -> String -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ TimeLocale -> String -> TimeOfDay -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale "%T%Q " TimeOfDay
tod String -> ShowS
forall a. [a] -> [a] -> [a]
++
                 TimeLocale -> String -> TimeZone -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale "%z" TimeZone
tz
    safeConvert (SqlLocalTime x :: LocalTime
x) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (LocalTime -> String) -> LocalTime -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> LocalTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q")) (LocalTime -> ConvertResult String)
-> LocalTime -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ LocalTime
x
    safeConvert (SqlZonedTime x :: ZonedTime
x) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (ZonedTime -> String) -> ZonedTime -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> ZonedTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q %z")) (ZonedTime -> ConvertResult String)
-> ZonedTime -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = 
        String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (UTCTime -> String) -> UTCTime -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> UTCTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q")) (UTCTime -> ConvertResult String)
-> UTCTime -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String) -> String -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Bool -> Fixed E12 -> String
forall a. HasResolution a => Bool -> Fixed a -> String
showFixed Bool
True Fixed E12
fixedval
            where fixedval :: Pico
                  fixedval :: Fixed E12
fixedval = Rational -> Fixed E12
forall a. Fractional a => Rational -> a
fromRational (Rational -> Fixed E12)
-> (POSIXTime -> Rational) -> POSIXTime -> Fixed E12
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Rational
forall a. Real a => a -> Rational
toRational (POSIXTime -> Fixed E12) -> POSIXTime -> Fixed E12
forall a b. (a -> b) -> a -> b
$ POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String) -> String -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Bool -> Fixed E12 -> String
forall a. HasResolution a => Bool -> Fixed a -> String
showFixed Bool
True Fixed E12
fixedval
            where fixedval :: Pico
                  fixedval :: Fixed E12
fixedval = Rational -> Fixed E12
forall a. Fractional a => Rational -> a
fromRational (Rational -> Fixed E12)
-> (POSIXTime -> Rational) -> POSIXTime -> Fixed E12
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Rational
forall a. Real a => a -> Rational
toRational (POSIXTime -> Fixed E12) -> POSIXTime -> Fixed E12
forall a b. (a -> b) -> a -> b
$ POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Integer -> String) -> Integer -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> String
forall a. Show a => a -> String
show (Integer -> ConvertResult String)
-> Integer -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = String -> ConvertResult String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ConvertResult String)
-> (Integer -> String) -> Integer -> ConvertResult String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> String
forall a. Show a => a -> String
show (Integer -> ConvertResult String)
-> Integer -> ConvertResult String
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult String
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible TS.Text SqlValue where
    safeConvert :: Text -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Text -> SqlValue) -> Text -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue) -> (Text -> String) -> Text -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
TS.unpack

instance Convertible SqlValue TS.Text where
    safeConvert :: SqlValue -> ConvertResult Text
safeConvert = (String -> Text) -> ConvertResult String -> ConvertResult Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Text
TS.pack (ConvertResult String -> ConvertResult Text)
-> (SqlValue -> ConvertResult String)
-> SqlValue
-> ConvertResult Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlValue -> ConvertResult String
forall a b. Convertible a b => a -> ConvertResult b
safeConvert

instance Convertible TL.Text SqlValue where
    safeConvert :: Text -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Text -> SqlValue) -> Text -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue) -> (Text -> String) -> Text -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
TL.unpack

instance Convertible SqlValue TL.Text where
    safeConvert :: SqlValue -> ConvertResult Text
safeConvert = (String -> Text) -> ConvertResult String -> ConvertResult Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Text
TL.pack (ConvertResult String -> ConvertResult Text)
-> (SqlValue -> ConvertResult String)
-> SqlValue
-> ConvertResult Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlValue -> ConvertResult String
forall a b. Convertible a b => a -> ConvertResult b
safeConvert

#ifdef __HUGS__
instance Typeable B.ByteString where
    typeOf _ = mkTypeName "ByteString"
#endif

instance Convertible B.ByteString SqlValue where
    safeConvert :: ByteString -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> SqlValue
SqlByteString
instance Convertible SqlValue B.ByteString where
    safeConvert :: SqlValue -> ConvertResult ByteString
safeConvert (SqlByteString x :: ByteString
x) = ByteString -> ConvertResult ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult ByteString
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert x :: SqlValue
x = SqlValue -> ConvertResult String
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
x ConvertResult String
-> (String -> ConvertResult ByteString) -> ConvertResult ByteString
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ByteString -> ConvertResult ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> ConvertResult ByteString)
-> (String -> ByteString) -> String -> ConvertResult ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BUTF8.fromString

instance Convertible BSL.ByteString SqlValue where
    safeConvert :: ByteString -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> SqlValue
SqlByteString (ByteString -> SqlValue)
-> (ByteString -> ByteString) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> ByteString
B.concat ([ByteString] -> ByteString)
-> (ByteString -> [ByteString]) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BSL.toChunks
instance Convertible SqlValue BSL.ByteString where
    safeConvert :: SqlValue -> ConvertResult ByteString
safeConvert x :: SqlValue
x = do ByteString
bs <- SqlValue -> ConvertResult ByteString
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
x
                       ByteString -> ConvertResult ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ([ByteString] -> ByteString
BSL.fromChunks [ByteString
bs])

instance Convertible Int SqlValue where
    safeConvert :: Int -> ConvertResult SqlValue
safeConvert x :: Int
x = 
        do Int64
i <- ((Int -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int
x)::ConvertResult Int64)
           SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> SqlValue -> ConvertResult SqlValue
forall a b. (a -> b) -> a -> b
$ Int64 -> SqlValue
SqlInt64 Int64
i
instance Convertible SqlValue Int where
    safeConvert :: SqlValue -> ConvertResult Int
safeConvert (SqlString x :: String
x) = String -> ConvertResult Int
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Int
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Int)
-> (ByteString -> String) -> ByteString -> ConvertResult Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Int -> ConvertResult Int
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> (Integer -> Int) -> ConvertResult Int
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> (Integer -> Int) -> ConvertResult Int
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral 
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Int
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> (Integer -> Int) -> ConvertResult Int
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral 
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> (Integer -> Int) -> ConvertResult Int
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert (SqlUTCTime x :: UTCTime
x) = UTCTime -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Int
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Int
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Int32 SqlValue where
    safeConvert :: Int32 -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Int32 -> SqlValue) -> Int32 -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> SqlValue
SqlInt32
instance Convertible SqlValue Int32 where
    safeConvert :: SqlValue -> ConvertResult Int32
safeConvert (SqlString x :: String
x) = String -> ConvertResult Int32
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Int32
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Int32)
-> (ByteString -> String) -> ByteString -> ConvertResult Int32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Int32 -> ConvertResult Int32
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Int32
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> (Integer -> Int32) -> ConvertResult Int32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Int32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Int32
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Int64 SqlValue where
    safeConvert :: Int64 -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Int64 -> SqlValue) -> Int64 -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> SqlValue
SqlInt64
instance Convertible SqlValue Int64 where
    safeConvert :: SqlValue -> ConvertResult Int64
safeConvert (SqlString x :: String
x) = String -> ConvertResult Int64
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Int64
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Int64)
-> (ByteString -> String) -> ByteString -> ConvertResult Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Int64 -> ConvertResult Int64
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Int64
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> (Integer -> Int64) -> ConvertResult Int64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Int64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Int64
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Word32 SqlValue where
    safeConvert :: Word32 -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Word32 -> SqlValue) -> Word32 -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> SqlValue
SqlWord32
instance Convertible SqlValue Word32 where
    safeConvert :: SqlValue -> ConvertResult Word32
safeConvert (SqlString x :: String
x) = String -> ConvertResult Word32
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Word32
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Word32)
-> (ByteString -> String) -> ByteString -> ConvertResult Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Word32 -> ConvertResult Word32
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Word32
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> (Integer -> Word32) -> ConvertResult Word32
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Word32
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Word32
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Word64 SqlValue where
    safeConvert :: Word64 -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Word64 -> SqlValue) -> Word64 -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> SqlValue
SqlWord64
instance Convertible SqlValue Word64 where
    safeConvert :: SqlValue -> ConvertResult Word64
safeConvert (SqlString x :: String
x) = String -> ConvertResult Word64
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Word64
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Word64)
-> (ByteString -> String) -> ByteString -> ConvertResult Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Word64 -> ConvertResult Word64
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Word64
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> (Integer -> Word64) -> ConvertResult Word64
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger SqlValue
y Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Word64
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Word64
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Integer SqlValue where
    safeConvert :: Integer -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Integer -> SqlValue) -> Integer -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> SqlValue
SqlInteger
instance Convertible SqlValue Integer where
    safeConvert :: SqlValue -> ConvertResult Integer
safeConvert (SqlString x :: String
x) = String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Integer)
-> (ByteString -> String) -> ByteString -> ConvertResult Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
x
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Char
x
    safeConvert (SqlBool x :: Bool
x) = Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1 else 0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert (SqlLocalDate x :: Day
x) = Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> ConvertResult Integer)
-> (Day -> Integer) -> Day -> ConvertResult Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> Integer
toModifiedJulianDay (Day -> ConvertResult Integer) -> Day -> ConvertResult Integer
forall a b. (a -> b) -> a -> b
$ Day
x
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = 
        Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> ConvertResult Integer)
-> (TimeOfDay -> Integer) -> TimeOfDay -> ConvertResult Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> (TimeOfDay -> Int) -> TimeOfDay -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> Int
forall a. Enum a => a -> Int
fromEnum (DiffTime -> Int) -> (TimeOfDay -> DiffTime) -> TimeOfDay -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> DiffTime
timeOfDayToTime (TimeOfDay -> ConvertResult Integer)
-> TimeOfDay -> ConvertResult Integer
forall a b. (a -> b) -> a -> b
$ TimeOfDay
x
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Integer
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult Integer
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = 
        Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> ConvertResult Integer)
-> (ZonedTime -> Integer) -> ZonedTime -> ConvertResult Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (POSIXTime -> Integer)
-> (ZonedTime -> POSIXTime) -> ZonedTime -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> POSIXTime
utcTimeToPOSIXSeconds (UTCTime -> POSIXTime)
-> (ZonedTime -> UTCTime) -> ZonedTime -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC (ZonedTime -> ConvertResult Integer)
-> ZonedTime -> ConvertResult Integer
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = UTCTime -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Integer
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Integer
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Bool SqlValue where
    safeConvert :: Bool -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Bool -> SqlValue) -> Bool -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> SqlValue
SqlBool
instance Convertible SqlValue Bool where
    safeConvert :: SqlValue -> ConvertResult Bool
safeConvert y :: SqlValue
y@(SqlString x :: String
x) = 
        case (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper String
x of
          "TRUE" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
True
          "T" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
True
          "FALSE" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
False
          "F" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
False
          "0" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
False
          "1" -> Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right Bool
True
          _ -> String -> SqlValue -> ConvertResult Bool
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "Cannot parse given String as Bool" SqlValue
y
    safeConvert (SqlByteString x :: ByteString
x) = (SqlValue -> ConvertResult Bool
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult Bool)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue)
-> (ByteString -> String) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Integer
x
    safeConvert (SqlChar x :: Char
x) = Int -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool (Char -> Int
ord Char
x)
    safeConvert (SqlBool x :: Bool
x) = Bool -> ConvertResult Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
x
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Bool
forall a. (Eq a, Num a) => a -> ConvertResult Bool
numToBool Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Bool
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

numToBool :: (Eq a, Num a) => a -> ConvertResult Bool
numToBool :: a -> ConvertResult Bool
numToBool x :: a
x = Bool -> ConvertResult Bool
forall a b. b -> Either a b
Right (a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= 0)

instance Convertible Char SqlValue where
    safeConvert :: Char -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Char -> SqlValue) -> Char -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> SqlValue
SqlChar
instance Convertible SqlValue Char where
    safeConvert :: SqlValue -> ConvertResult Char
safeConvert (SqlString [x :: Char
x]) = Char -> ConvertResult Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
x
    safeConvert y :: SqlValue
y@(SqlString _) = String -> SqlValue -> ConvertResult Char
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "String length /= 1" SqlValue
y
    safeConvert (SqlByteString x :: ByteString
x) =
          SqlValue -> ConvertResult Char
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult Char)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue)
-> (ByteString -> String) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString (ByteString -> ConvertResult Char)
-> ByteString -> ConvertResult Char
forall a b. (a -> b) -> a -> b
$ ByteString
x
    safeConvert y :: SqlValue
y@(SqlInt32 _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInt64 _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord32 _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord64 _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInteger _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlChar x :: Char
x) = Char -> ConvertResult Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
x
    safeConvert (SqlBool x :: Bool
x) = Char -> ConvertResult Char
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then '1' else '0')
    safeConvert y :: SqlValue
y@(SqlDouble _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlRational _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Char
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Double SqlValue where
    safeConvert :: Double -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Double -> SqlValue) -> Double -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> SqlValue
SqlDouble
instance Convertible SqlValue Double where
    safeConvert :: SqlValue -> ConvertResult Double
safeConvert (SqlString x :: String
x) = String -> ConvertResult Double
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Double
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Double)
-> (ByteString -> String) -> ByteString -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return (Double -> ConvertResult Double)
-> (Char -> Double) -> Char -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> (Char -> Int) -> Char -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum (Char -> ConvertResult Double) -> Char -> ConvertResult Double
forall a b. (a -> b) -> a -> b
$ Char
x
    safeConvert (SqlBool x :: Bool
x) = Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
x then 1.0 else 0.0)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = ((SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y)::ConvertResult Integer) ConvertResult Integer
-> (Integer -> ConvertResult Double) -> ConvertResult Double
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 
                                     (Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return (Double -> ConvertResult Double)
-> (Integer -> Double) -> Integer -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral)
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = 
        Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return (Double -> ConvertResult Double)
-> (TimeOfDay -> Double) -> TimeOfDay -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> (TimeOfDay -> Rational) -> TimeOfDay -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> Rational
forall a. Real a => a -> Rational
toRational (DiffTime -> Rational)
-> (TimeOfDay -> DiffTime) -> TimeOfDay -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> DiffTime
timeOfDayToTime (TimeOfDay -> ConvertResult Double)
-> TimeOfDay -> ConvertResult Double
forall a b. (a -> b) -> a -> b
$ TimeOfDay
x
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Double
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult Double
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = 
        SqlValue -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult Double)
-> (ZonedTime -> SqlValue) -> ZonedTime -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> SqlValue
SqlUTCTime (UTCTime -> SqlValue)
-> (ZonedTime -> UTCTime) -> ZonedTime -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC (ZonedTime -> ConvertResult Double)
-> ZonedTime -> ConvertResult Double
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = 
        Double -> ConvertResult Double
forall (m :: * -> *) a. Monad m => a -> m a
return (Double -> ConvertResult Double)
-> (UTCTime -> Double) -> UTCTime -> ConvertResult Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double) -> (UTCTime -> Rational) -> UTCTime -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Rational
forall a. Real a => a -> Rational
toRational (POSIXTime -> Rational)
-> (UTCTime -> POSIXTime) -> UTCTime -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> POSIXTime
utcTimeToPOSIXSeconds (UTCTime -> ConvertResult Double)
-> UTCTime -> ConvertResult Double
forall a b. (a -> b) -> a -> b
$ UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = Integer -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult Double
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Double
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Rational SqlValue where
    safeConvert :: Rational -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Rational -> SqlValue) -> Rational -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> SqlValue
SqlRational
instance Convertible SqlValue Rational where
    safeConvert :: SqlValue -> ConvertResult Rational
safeConvert (SqlString x :: String
x) = String -> ConvertResult Rational
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult Rational
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' (String -> ConvertResult Rational)
-> (ByteString -> String) -> ByteString -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString) ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Int32 -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = Int64 -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = Word32 -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = Word64 -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Word64
x
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x
    safeConvert (SqlChar x :: Char
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> (Char -> Rational) -> Char -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Rational) -> (Char -> Int) -> Char -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum (Char -> ConvertResult Rational) -> Char -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ Char
x
    safeConvert (SqlBool x :: Bool
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> Rational -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ if Bool
x then Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (1::Int) 
                                       else Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (0::Int)
    safeConvert (SqlDouble x :: Double
x) = Double -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Double
x
    safeConvert (SqlRational x :: Rational
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = ((SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y)::ConvertResult Integer) ConvertResult Integer
-> (Integer -> ConvertResult Rational) -> ConvertResult Rational
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 
                                     (Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> (Integer -> Rational) -> Integer -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral)
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> (TimeOfDay -> Rational) -> TimeOfDay -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> Rational
forall a. Real a => a -> Rational
toRational (DiffTime -> Rational)
-> (TimeOfDay -> DiffTime) -> TimeOfDay -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> DiffTime
timeOfDayToTime (TimeOfDay -> ConvertResult Rational)
-> TimeOfDay -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ TimeOfDay
x
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Rational
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult Rational
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = SqlValue -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult Rational)
-> (ZonedTime -> SqlValue) -> ZonedTime -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> SqlValue
SqlUTCTime (UTCTime -> SqlValue)
-> (ZonedTime -> UTCTime) -> ZonedTime -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC (ZonedTime -> ConvertResult Rational)
-> ZonedTime -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = UTCTime -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = POSIXTime -> ConvertResult Rational
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> (Integer -> Rational) -> Integer -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult Rational)
-> Integer -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = Rational -> ConvertResult Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> ConvertResult Rational)
-> (Integer -> Rational) -> Integer -> ConvertResult Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult Rational)
-> Integer -> ConvertResult Rational
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Rational
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible Day SqlValue where
    safeConvert :: Day -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (Day -> SqlValue) -> Day -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> SqlValue
SqlLocalDate
instance Convertible SqlValue Day where
    safeConvert :: SqlValue -> ConvertResult Day
safeConvert (SqlString x :: String
x) = String -> String -> ConvertResult Day
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' (Maybe String -> String
iso8601DateFormat Maybe String
forall a. Maybe a
Nothing) String
x
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult Day
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert (SqlInt32 x :: Int32
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x}
    safeConvert (SqlInt64 x :: Int64
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x}
    safeConvert (SqlWord32 x :: Word32
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x}
    safeConvert (SqlWord64 x :: Word64
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x}
    safeConvert (SqlInteger x :: Integer
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Integer
x}
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = 
        Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day) -> Day -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay :: Integer -> Day
ModifiedJulianDay {toModifiedJulianDay :: Integer
toModifiedJulianDay = Double -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Double
x}
    safeConvert (SqlRational x :: Rational
x) = SqlValue -> ConvertResult Day
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult Day)
-> (Rational -> SqlValue) -> Rational -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> SqlValue
SqlDouble (Double -> SqlValue)
-> (Rational -> Double) -> Rational -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> ConvertResult Day) -> Rational -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ Rational
x
    safeConvert (SqlLocalDate x :: Day
x) = Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return Day
x
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlLocalTime x :: LocalTime
x) = Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day)
-> (LocalTime -> Day) -> LocalTime -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> Day
localDay (LocalTime -> ConvertResult Day) -> LocalTime -> ConvertResult Day
forall a b. (a -> b) -> a -> b
$ LocalTime
x
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult Day) -> ConvertResult Day
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day)
-> (LocalTime -> Day) -> LocalTime -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> Day
localDay
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult Day) -> ConvertResult Day
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day)
-> (LocalTime -> Day) -> LocalTime -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> Day
localDay
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult Day) -> ConvertResult Day
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day)
-> (LocalTime -> Day) -> LocalTime -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> Day
localDay
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult Day) -> ConvertResult Day
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Day -> ConvertResult Day
forall (m :: * -> *) a. Monad m => a -> m a
return (Day -> ConvertResult Day)
-> (LocalTime -> Day) -> LocalTime -> ConvertResult Day
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> Day
localDay
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlValue
SqlNull) = SqlValue -> ConvertResult Day
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible TimeOfDay SqlValue where
    safeConvert :: TimeOfDay -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (TimeOfDay -> SqlValue) -> TimeOfDay -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> SqlValue
SqlLocalTimeOfDay
instance Convertible SqlValue TimeOfDay where
    safeConvert :: SqlValue -> ConvertResult TimeOfDay
safeConvert (SqlString x :: String
x) = String -> String -> ConvertResult TimeOfDay
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' "%T%Q" String
x
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult TimeOfDay
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert (SqlInt32 x :: Int32
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Int32 -> TimeOfDay) -> Int32 -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Int32 -> DiffTime) -> Int32 -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> ConvertResult TimeOfDay)
-> Int32 -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Int64 -> TimeOfDay) -> Int64 -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Int64 -> DiffTime) -> Int64 -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> ConvertResult TimeOfDay)
-> Int64 -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Word32 -> TimeOfDay) -> Word32 -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Word32 -> DiffTime) -> Word32 -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> ConvertResult TimeOfDay)
-> Word32 -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Word64 -> TimeOfDay) -> Word64 -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Word64 -> DiffTime) -> Word64 -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> ConvertResult TimeOfDay)
-> Word64 -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Word64
x
    safeConvert (SqlInteger x :: Integer
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Integer -> TimeOfDay) -> Integer -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Integer -> DiffTime) -> Integer -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DiffTime
forall a. Num a => Integer -> a
fromInteger (Integer -> ConvertResult TimeOfDay)
-> Integer -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = 
        TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (Integer -> TimeOfDay) -> Integer -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
timeToTimeOfDay (DiffTime -> TimeOfDay)
-> (Integer -> DiffTime) -> Integer -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult TimeOfDay)
-> Integer -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ ((Double -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Double
x)::Integer)
    safeConvert (SqlRational x :: Rational
x) = SqlValue -> ConvertResult TimeOfDay
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult TimeOfDay)
-> (Rational -> SqlValue) -> Rational -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> SqlValue
SqlDouble (Double -> SqlValue)
-> (Rational -> Double) -> Rational -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> ConvertResult TimeOfDay)
-> Rational -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return TimeOfDay
x
    safeConvert (SqlZonedLocalTimeOfDay tod :: TimeOfDay
tod _) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return TimeOfDay
tod
    safeConvert (SqlLocalTime x :: LocalTime
x) = TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (LocalTime -> TimeOfDay) -> LocalTime -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> TimeOfDay
localTimeOfDay (LocalTime -> ConvertResult TimeOfDay)
-> LocalTime -> ConvertResult TimeOfDay
forall a b. (a -> b) -> a -> b
$ LocalTime
x
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult TimeOfDay)
-> ConvertResult TimeOfDay
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (LocalTime -> TimeOfDay) -> LocalTime -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> TimeOfDay
localTimeOfDay
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult TimeOfDay)
-> ConvertResult TimeOfDay
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (LocalTime -> TimeOfDay) -> LocalTime -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> TimeOfDay
localTimeOfDay
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult TimeOfDay)
-> ConvertResult TimeOfDay
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (LocalTime -> TimeOfDay) -> LocalTime -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> TimeOfDay
localTimeOfDay
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult LocalTime
-> (LocalTime -> ConvertResult TimeOfDay)
-> ConvertResult TimeOfDay
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TimeOfDay -> ConvertResult TimeOfDay
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> ConvertResult TimeOfDay)
-> (LocalTime -> TimeOfDay) -> LocalTime -> ConvertResult TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> TimeOfDay
localTimeOfDay
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult TimeOfDay
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible (TimeOfDay, TimeZone) SqlValue where
    safeConvert :: (TimeOfDay, TimeZone) -> ConvertResult SqlValue
safeConvert (tod :: TimeOfDay
tod, tz :: TimeZone
tz) = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay -> TimeZone -> SqlValue
SqlZonedLocalTimeOfDay TimeOfDay
tod TimeZone
tz)
instance Convertible SqlValue (TimeOfDay, TimeZone) where
    safeConvert :: SqlValue -> ConvertResult (TimeOfDay, TimeZone)
safeConvert (SqlString x :: String
x) = 
        do TimeOfDay
tod <- String -> String -> ConvertResult TimeOfDay
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' "%T%Q %z" String
x
#if MIN_TIME_15
           TimeZone
tz <- case Bool -> TimeLocale -> String -> String -> Maybe TimeZone
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale "%T%Q %z" String
x of
#else
           tz <- case parseTime defaultTimeLocale "%T%Q %z" x of
#endif
                      Nothing -> String -> SqlValue -> ConvertResult TimeZone
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "Couldn't extract timezone in" (String -> SqlValue
SqlString String
x)
                      Just y :: TimeZone
y -> TimeZone -> ConvertResult TimeZone
forall a b. b -> Either a b
Right TimeZone
y
           (TimeOfDay, TimeZone) -> ConvertResult (TimeOfDay, TimeZone)
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay
tod, TimeZone
tz)
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert y :: SqlValue
y@(SqlInt32 _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInt64 _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord32 _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord64 _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInteger _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDouble _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlRational _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedLocalTimeOfDay x :: TimeOfDay
x y :: TimeZone
y) = (TimeOfDay, TimeZone) -> ConvertResult (TimeOfDay, TimeZone)
forall (m :: * -> *) a. Monad m => a -> m a
return (TimeOfDay
x, TimeZone
y)
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = (TimeOfDay, TimeZone) -> ConvertResult (TimeOfDay, TimeZone)
forall (m :: * -> *) a. Monad m => a -> m a
return (LocalTime -> TimeOfDay
localTimeOfDay (LocalTime -> TimeOfDay)
-> (ZonedTime -> LocalTime) -> ZonedTime -> TimeOfDay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> LocalTime
zonedTimeToLocalTime (ZonedTime -> TimeOfDay) -> ZonedTime -> TimeOfDay
forall a b. (a -> b) -> a -> b
$ ZonedTime
x,
                                           ZonedTime -> TimeZone
zonedTimeZone ZonedTime
x)
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult (TimeOfDay, TimeZone)
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible LocalTime SqlValue where
    safeConvert :: LocalTime -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (LocalTime -> SqlValue) -> LocalTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalTime -> SqlValue
SqlLocalTime
instance Convertible SqlValue LocalTime where
    safeConvert :: SqlValue -> ConvertResult LocalTime
safeConvert (SqlString x :: String
x) = String -> String -> ConvertResult LocalTime
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q")) String
x
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult LocalTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert y :: SqlValue
y@(SqlInt32 _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInt64 _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord32 _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlWord64 _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlInteger _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDouble _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlRational _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlLocalTime x :: LocalTime
x) = LocalTime -> ConvertResult LocalTime
forall (m :: * -> *) a. Monad m => a -> m a
return LocalTime
x
    safeConvert (SqlZonedTime x :: ZonedTime
x) = LocalTime -> ConvertResult LocalTime
forall (m :: * -> *) a. Monad m => a -> m a
return (LocalTime -> ConvertResult LocalTime)
-> (ZonedTime -> LocalTime) -> ZonedTime -> ConvertResult LocalTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> LocalTime
zonedTimeToLocalTime (ZonedTime -> ConvertResult LocalTime)
-> ZonedTime -> ConvertResult LocalTime
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult ZonedTime
-> (ZonedTime -> ConvertResult LocalTime)
-> ConvertResult LocalTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LocalTime -> ConvertResult LocalTime
forall (m :: * -> *) a. Monad m => a -> m a
return (LocalTime -> ConvertResult LocalTime)
-> (ZonedTime -> LocalTime) -> ZonedTime -> ConvertResult LocalTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> LocalTime
zonedTimeToLocalTime
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult ZonedTime
-> (ZonedTime -> ConvertResult LocalTime)
-> ConvertResult LocalTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LocalTime -> ConvertResult LocalTime
forall (m :: * -> *) a. Monad m => a -> m a
return (LocalTime -> ConvertResult LocalTime)
-> (ZonedTime -> LocalTime) -> ZonedTime -> ConvertResult LocalTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> LocalTime
zonedTimeToLocalTime
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult ZonedTime
-> (ZonedTime -> ConvertResult LocalTime)
-> ConvertResult LocalTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LocalTime -> ConvertResult LocalTime
forall (m :: * -> *) a. Monad m => a -> m a
return (LocalTime -> ConvertResult LocalTime)
-> (ZonedTime -> LocalTime) -> ZonedTime -> ConvertResult LocalTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> LocalTime
zonedTimeToLocalTime
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult LocalTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible ZonedTime SqlValue where
    safeConvert :: ZonedTime -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (ZonedTime -> SqlValue) -> ZonedTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> SqlValue
SqlZonedTime
instance Convertible SqlValue ZonedTime where
    safeConvert :: SqlValue -> ConvertResult ZonedTime
safeConvert (SqlString x :: String
x) = String -> String -> ConvertResult ZonedTime
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q %z")) String
x
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert (SqlInt32 x :: Int32
x) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (Integer -> SqlValue
SqlInteger (Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x))
    safeConvert (SqlInt64 x :: Int64
x) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (Integer -> SqlValue
SqlInteger (Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x))
    safeConvert (SqlWord32 x :: Word32
x) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (Integer -> SqlValue
SqlInteger (Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x))
    safeConvert (SqlWord64 x :: Word64
x) = SqlValue -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (Integer -> SqlValue
SqlInteger (Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x))
    safeConvert y :: SqlValue
y@(SqlInteger _) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult UTCTime
-> (UTCTime -> ConvertResult ZonedTime) -> ConvertResult ZonedTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDouble _) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult UTCTime
-> (UTCTime -> ConvertResult ZonedTime) -> ConvertResult ZonedTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc
    safeConvert y :: SqlValue
y@(SqlRational _) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult UTCTime
-> (UTCTime -> ConvertResult ZonedTime) -> ConvertResult ZonedTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc (UTCTime -> ConvertResult ZonedTime)
-> UTCTime -> ConvertResult ZonedTime
forall a b. (a -> b) -> a -> b
$ UTCTime
x
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult UTCTime
-> (UTCTime -> ConvertResult ZonedTime) -> ConvertResult ZonedTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult UTCTime
-> (UTCTime -> ConvertResult ZonedTime) -> ConvertResult ZonedTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZonedTime -> ConvertResult ZonedTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> ConvertResult ZonedTime)
-> (UTCTime -> ZonedTime) -> UTCTime -> ConvertResult ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
utc
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult ZonedTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible UTCTime SqlValue where
    safeConvert :: UTCTime -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (UTCTime -> SqlValue) -> UTCTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> SqlValue
SqlUTCTime
instance Convertible SqlValue UTCTime where
    safeConvert :: SqlValue -> ConvertResult UTCTime
safeConvert (SqlString x :: String
x) = String -> String -> ConvertResult UTCTime
forall t.
(Typeable t, Convertible SqlValue t, ParseTime t) =>
String -> String -> ConvertResult t
parseTime' (Maybe String -> String
iso8601DateFormat (String -> Maybe String
forall a. a -> Maybe a
Just "%T%Q")) String
x
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult UTCTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (String -> SqlValue
SqlString (ByteString -> String
BUTF8.toString ByteString
x))
    safeConvert y :: SqlValue
y@(SqlInt32 _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlInt64 _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlWord32 _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlWord64 _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlInteger _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlDouble _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlRational _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (ZonedTime -> UTCTime) -> ZonedTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC (ZonedTime -> ConvertResult UTCTime)
-> ZonedTime -> ConvertResult UTCTime
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return UTCTime
x
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = String -> SqlValue -> ConvertResult UTCTime
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "incompatible types (did you mean SqlPOSIXTime?)" SqlValue
y
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime (POSIXTime -> ConvertResult UTCTime)
-> POSIXTime -> ConvertResult UTCTime
forall a b. (a -> b) -> a -> b
$ POSIXTime
x
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult UTCTime) -> ConvertResult UTCTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UTCTime -> ConvertResult UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> ConvertResult UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> ConvertResult UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
posixSecondsToUTCTime
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = String -> SqlValue -> ConvertResult UTCTime
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "incompatible types (did you mean SqlPOSIXTime?)" SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult UTCTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

stringToPico :: String -> ConvertResult Pico
stringToPico :: String -> ConvertResult (Fixed E12)
stringToPico s :: String
s =
    let (base :: String
base, fracwithdot :: String
fracwithdot) = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '.') String
s
        shortfrac :: String
shortfrac = Int -> ShowS
forall a. Int -> [a] -> [a]
drop 1 String
fracwithdot -- strip of dot; don't use tail because it may be empty
        frac :: String
frac = Int -> ShowS
forall a. Int -> [a] -> [a]
take 12 (Int -> Char -> ShowS
forall a. Int -> a -> [a] -> [a]
rpad 12 '0' String
shortfrac)
        rpad :: Int -> a -> [a] -> [a]
                -- next line lifted from Data.Time
        rpad :: Int -> a -> [a] -> [a]
rpad n :: Int
n c :: a
c xs :: [a]
xs = [a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ Int -> a -> [a]
forall a. Int -> a -> [a]
replicate (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs) a
c
        mkPico :: Integer -> Integer -> Pico
                -- next line also lifted from Data.Time
        mkPico :: Integer -> Integer -> Fixed E12
mkPico i :: Integer
i f :: Integer
f = Integer -> Fixed E12
forall a. Num a => Integer -> a
fromInteger Integer
i Fixed E12 -> Fixed E12 -> Fixed E12
forall a. Num a => a -> a -> a
+ Rational -> Fixed E12
forall a. Fractional a => Rational -> a
fromRational (Integer
f Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% 1000000000000)
    in do Integer
parsedBase <- String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
base
          Integer
parsedFrac <- String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
frac
          Fixed E12 -> ConvertResult (Fixed E12)
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Integer -> Fixed E12
mkPico Integer
parsedBase Integer
parsedFrac)

instance Convertible NominalDiffTime SqlValue where
    safeConvert :: POSIXTime -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (POSIXTime -> SqlValue) -> POSIXTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> SqlValue
SqlDiffTime
instance Convertible SqlValue NominalDiffTime where
    safeConvert :: SqlValue -> ConvertResult POSIXTime
safeConvert (SqlString x :: String
x) = String -> ConvertResult (Fixed E12)
stringToPico String
x ConvertResult (Fixed E12)
-> (Fixed E12 -> ConvertResult POSIXTime)
-> ConvertResult POSIXTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 
                                POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Fixed E12 -> POSIXTime) -> Fixed E12 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed E12 -> POSIXTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac
    safeConvert (SqlByteString x :: ByteString
x) = (String -> ConvertResult (Fixed E12)
stringToPico (ByteString -> String
BUTF8.toString ByteString
x)) ConvertResult (Fixed E12)
-> (Fixed E12 -> ConvertResult POSIXTime)
-> ConvertResult POSIXTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
                                    POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Fixed E12 -> POSIXTime) -> Fixed E12 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed E12 -> POSIXTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac
    safeConvert (SqlInt32 x :: Int32
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Int32 -> POSIXTime) -> Int32 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> ConvertResult POSIXTime)
-> Int32 -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Int64 -> POSIXTime) -> Int64 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> ConvertResult POSIXTime)
-> Int64 -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Word32 -> POSIXTime) -> Word32 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> ConvertResult POSIXTime)
-> Word32 -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Word64 -> POSIXTime) -> Word64 -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> ConvertResult POSIXTime)
-> Word64 -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Word64
x
    safeConvert (SqlInteger x :: Integer
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Integer -> POSIXTime) -> Integer -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult POSIXTime)
-> Integer -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult POSIXTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult POSIXTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Double -> POSIXTime) -> Double -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> POSIXTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> POSIXTime)
-> (Double -> Rational) -> Double -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational (Double -> ConvertResult POSIXTime)
-> Double -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Double
x
    safeConvert (SqlRational x :: Rational
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Rational -> POSIXTime) -> Rational -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> POSIXTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> ConvertResult POSIXTime)
-> Rational -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Rational
x
    safeConvert (SqlLocalDate x :: Day
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Day -> POSIXTime) -> Day -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> POSIXTime) -> (Day -> Integer) -> Day -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\y :: Integer
y -> Integer
y Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* 60 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* 60 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* 24) (Integer -> Integer) -> (Day -> Integer) -> Day -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
                               Day -> Integer
toModifiedJulianDay (Day -> ConvertResult POSIXTime) -> Day -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Day
x
    safeConvert (SqlLocalTimeOfDay x :: TimeOfDay
x) = 
        POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (TimeOfDay -> POSIXTime) -> TimeOfDay -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> POSIXTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> POSIXTime)
-> (TimeOfDay -> Rational) -> TimeOfDay -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> Rational
forall a. Real a => a -> Rational
toRational (DiffTime -> Rational)
-> (TimeOfDay -> DiffTime) -> TimeOfDay -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> DiffTime
timeOfDayToTime (TimeOfDay -> ConvertResult POSIXTime)
-> TimeOfDay -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ TimeOfDay
x
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult POSIXTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult POSIXTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlZonedTime x :: ZonedTime
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (ZonedTime -> POSIXTime) -> ZonedTime -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> POSIXTime
utcTimeToPOSIXSeconds (UTCTime -> POSIXTime)
-> (ZonedTime -> UTCTime) -> ZonedTime -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC (ZonedTime -> ConvertResult POSIXTime)
-> ZonedTime -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ ZonedTime
x
    safeConvert (SqlUTCTime x :: UTCTime
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (UTCTime -> POSIXTime) -> UTCTime -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> POSIXTime
utcTimeToPOSIXSeconds (UTCTime -> ConvertResult POSIXTime)
-> UTCTime -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ UTCTime
x
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return POSIXTime
x
    safeConvert (SqlPOSIXTime x :: POSIXTime
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return POSIXTime
x
    safeConvert (SqlEpochTime x :: Integer
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Integer -> POSIXTime) -> Integer -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult POSIXTime)
-> Integer -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert (SqlTimeDiff x :: Integer
x) = POSIXTime -> ConvertResult POSIXTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> ConvertResult POSIXTime)
-> (Integer -> POSIXTime) -> Integer -> ConvertResult POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult POSIXTime)
-> Integer -> ConvertResult POSIXTime
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult POSIXTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible ST.ClockTime SqlValue where
    safeConvert :: ClockTime -> ConvertResult SqlValue
safeConvert x :: ClockTime
x = ClockTime -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert ClockTime
x ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult SqlValue) -> ConvertResult SqlValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (POSIXTime -> SqlValue) -> POSIXTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> SqlValue
SqlPOSIXTime
instance Convertible SqlValue ST.ClockTime where
    safeConvert :: SqlValue -> ConvertResult ClockTime
safeConvert (SqlString x :: String
x) = do Integer
r <- String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x
                                   ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
r 0
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult ClockTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult ClockTime)
-> (ByteString -> SqlValue)
-> ByteString
-> ConvertResult ClockTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue)
-> (ByteString -> String) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString (ByteString -> ConvertResult ClockTime)
-> ByteString -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x) 0
    safeConvert (SqlInt64 x :: Int64
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x) 0
    safeConvert (SqlWord32 x :: Word32
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x) 0
    safeConvert (SqlWord64 x :: Word64
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x) 0
    safeConvert (SqlInteger x :: Integer
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
x 0
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Double -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Double
x) 0
    safeConvert (SqlRational x :: Rational
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD (Rational -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Rational
x) 0
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult Integer
-> (Integer -> ConvertResult ClockTime) -> ConvertResult ClockTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\z :: Integer
z -> ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
z 0)
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult Integer
-> (Integer -> ConvertResult ClockTime) -> ConvertResult ClockTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\z :: Integer
z -> ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
z 0)
    safeConvert y :: SqlValue
y@(SqlDiffTime _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y ConvertResult Integer
-> (Integer -> ConvertResult ClockTime) -> ConvertResult ClockTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\z :: Integer
z -> ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
z 0)
    safeConvert (SqlEpochTime x :: Integer
x) = ClockTime -> ConvertResult ClockTime
forall (m :: * -> *) a. Monad m => a -> m a
return (ClockTime -> ConvertResult ClockTime)
-> ClockTime -> ConvertResult ClockTime
forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> ClockTime
ST.TOD Integer
x 0
    safeConvert y :: SqlValue
y@(SqlTimeDiff _) = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult ClockTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible ST.TimeDiff SqlValue where
    safeConvert :: TimeDiff -> ConvertResult SqlValue
safeConvert x :: TimeDiff
x = TimeDiff -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert TimeDiff
x ConvertResult POSIXTime
-> (POSIXTime -> ConvertResult SqlValue) -> ConvertResult SqlValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (POSIXTime -> SqlValue) -> POSIXTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> SqlValue
SqlDiffTime
instance Convertible SqlValue ST.TimeDiff where
    safeConvert :: SqlValue -> ConvertResult TimeDiff
safeConvert y :: SqlValue
y@(SqlString _) = 
        do POSIXTime
r <- SqlValue -> ConvertResult POSIXTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
y
           SqlValue -> ConvertResult TimeDiff
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (POSIXTime -> SqlValue
SqlDiffTime POSIXTime
r)
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult TimeDiff
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult TimeDiff)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult TimeDiff
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue)
-> (ByteString -> String) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString (ByteString -> ConvertResult TimeDiff)
-> ByteString -> ConvertResult TimeDiff
forall a b. (a -> b) -> a -> b
$ ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = Integer -> ConvertResult TimeDiff
secs2td (Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x)
    safeConvert (SqlInt64 x :: Int64
x) = Integer -> ConvertResult TimeDiff
secs2td (Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x)
    safeConvert (SqlWord32 x :: Word32
x) = Integer -> ConvertResult TimeDiff
secs2td (Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x)
    safeConvert (SqlWord64 x :: Word64
x) = Integer -> ConvertResult TimeDiff
secs2td (Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x)
    safeConvert (SqlInteger x :: Integer
x) = Integer -> ConvertResult TimeDiff
secs2td Integer
x
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = Integer -> ConvertResult TimeDiff
secs2td (Double -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Double
x)
    safeConvert (SqlRational x :: Rational
x) = Integer -> ConvertResult TimeDiff
secs2td (Rational -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate Rational
x)
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDiffTime x :: POSIXTime
x) = POSIXTime -> ConvertResult TimeDiff
forall a b. Convertible a b => a -> ConvertResult b
safeConvert POSIXTime
x
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlTimeDiff x :: Integer
x) = Integer -> ConvertResult TimeDiff
secs2td Integer
x
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult TimeDiff
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible DiffTime SqlValue where
    safeConvert :: DiffTime -> ConvertResult SqlValue
safeConvert = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (DiffTime -> SqlValue) -> DiffTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> SqlValue
SqlDiffTime (POSIXTime -> SqlValue)
-> (DiffTime -> POSIXTime) -> DiffTime -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> POSIXTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> POSIXTime)
-> (DiffTime -> Rational) -> DiffTime -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> Rational
forall a. Real a => a -> Rational
toRational
instance Convertible SqlValue DiffTime where
    safeConvert :: SqlValue -> ConvertResult DiffTime
safeConvert (SqlString x :: String
x) = String -> ConvertResult Integer
forall a.
(Typeable a, Read a, Convertible SqlValue a) =>
String -> ConvertResult a
read' String
x ConvertResult Integer
-> (Integer -> ConvertResult DiffTime) -> ConvertResult DiffTime
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Integer -> DiffTime) -> Integer -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DiffTime
forall a. Num a => Integer -> a
fromInteger
    safeConvert (SqlByteString x :: ByteString
x) = SqlValue -> ConvertResult DiffTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert (SqlValue -> ConvertResult DiffTime)
-> (ByteString -> SqlValue) -> ByteString -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SqlValue
SqlString (String -> SqlValue)
-> (ByteString -> String) -> ByteString -> SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BUTF8.toString (ByteString -> ConvertResult DiffTime)
-> ByteString -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ ByteString
x
    safeConvert (SqlInt32 x :: Int32
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Int32 -> DiffTime) -> Int32 -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> ConvertResult DiffTime)
-> Int32 -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Int32
x
    safeConvert (SqlInt64 x :: Int64
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Int64 -> DiffTime) -> Int64 -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> ConvertResult DiffTime)
-> Int64 -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Int64
x
    safeConvert (SqlWord32 x :: Word32
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Word32 -> DiffTime) -> Word32 -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> ConvertResult DiffTime)
-> Word32 -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Word32
x
    safeConvert (SqlWord64 x :: Word64
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Word64 -> DiffTime) -> Word64 -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> ConvertResult DiffTime)
-> Word64 -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Word64
x
    safeConvert (SqlInteger x :: Integer
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Integer -> DiffTime) -> Integer -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult DiffTime)
-> Integer -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@(SqlChar _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlBool _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDouble x :: Double
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Double -> DiffTime) -> Double -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> DiffTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> DiffTime)
-> (Double -> Rational) -> Double -> DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational (Double -> ConvertResult DiffTime)
-> Double -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Double
x
    safeConvert (SqlRational x :: Rational
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Rational -> DiffTime) -> Rational -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> DiffTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> ConvertResult DiffTime)
-> Rational -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Rational
x
    safeConvert y :: SqlValue
y@(SqlLocalDate _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTimeOfDay _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedLocalTimeOfDay _ _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlLocalTime _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlZonedTime _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlUTCTime _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlDiffTime x :: POSIXTime
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (POSIXTime -> DiffTime) -> POSIXTime -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> DiffTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> DiffTime)
-> (POSIXTime -> Rational) -> POSIXTime -> DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Rational
forall a. Real a => a -> Rational
toRational (POSIXTime -> ConvertResult DiffTime)
-> POSIXTime -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ POSIXTime
x
    safeConvert y :: SqlValue
y@(SqlPOSIXTime _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert y :: SqlValue
y@(SqlEpochTime _) = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y
    safeConvert (SqlTimeDiff x :: Integer
x) = DiffTime -> ConvertResult DiffTime
forall (m :: * -> *) a. Monad m => a -> m a
return (DiffTime -> ConvertResult DiffTime)
-> (Integer -> DiffTime) -> Integer -> ConvertResult DiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> DiffTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> ConvertResult DiffTime)
-> Integer -> ConvertResult DiffTime
forall a b. (a -> b) -> a -> b
$ Integer
x
    safeConvert y :: SqlValue
y@SqlValue
SqlNull = SqlValue -> ConvertResult DiffTime
forall a.
(Typeable a, Convertible SqlValue a) =>
SqlValue -> ConvertResult a
quickError SqlValue
y

instance Convertible ST.CalendarTime SqlValue where
    -- convert via ZonedTime
    safeConvert :: CalendarTime -> ConvertResult SqlValue
safeConvert x :: CalendarTime
x = CalendarTime -> ConvertResult ZonedTime
forall a b. Convertible a b => a -> ConvertResult b
safeConvert CalendarTime
x ConvertResult ZonedTime
-> (ZonedTime -> ConvertResult SqlValue) -> ConvertResult SqlValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlValue -> ConvertResult SqlValue)
-> (ZonedTime -> SqlValue) -> ZonedTime -> ConvertResult SqlValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> SqlValue
SqlZonedTime
instance Convertible SqlValue ST.CalendarTime where
    -- convert via ZonedTime
    safeConvert :: SqlValue -> ConvertResult CalendarTime
safeConvert = ZonedTime -> SqlValue -> ConvertResult CalendarTime
forall a b c.
(Convertible a b, Convertible b c) =>
b -> a -> ConvertResult c
convertVia (ZonedTime
forall a. HasCallStack => a
undefined::ZonedTime)

instance (Convertible a SqlValue) => Convertible (Maybe a) SqlValue where
    safeConvert :: Maybe a -> ConvertResult SqlValue
safeConvert Nothing = SqlValue -> ConvertResult SqlValue
forall (m :: * -> *) a. Monad m => a -> m a
return SqlValue
SqlNull
    safeConvert (Just a :: a
a) = a -> ConvertResult SqlValue
forall a b. Convertible a b => a -> ConvertResult b
safeConvert a
a
instance (Convertible SqlValue a) => Convertible SqlValue (Maybe a) where
    safeConvert :: SqlValue -> ConvertResult (Maybe a)
safeConvert SqlNull = Maybe a -> ConvertResult (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
    safeConvert a :: SqlValue
a = SqlValue -> ConvertResult a
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
a ConvertResult a
-> (a -> ConvertResult (Maybe a)) -> ConvertResult (Maybe a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Maybe a -> ConvertResult (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> ConvertResult (Maybe a))
-> (a -> Maybe a) -> a -> ConvertResult (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just)

viaInteger' :: (Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
               Typeable a) => SqlValue -> (Integer -> ConvertResult a) -> ConvertResult a
viaInteger' :: SqlValue -> (Integer -> ConvertResult a) -> ConvertResult a
viaInteger' sv :: SqlValue
sv func :: Integer -> ConvertResult a
func = 
    do Integer
i <- ((SqlValue -> ConvertResult Integer
forall a b. Convertible a b => a -> ConvertResult b
safeConvert SqlValue
sv)::ConvertResult Integer)
       (Integer -> ConvertResult a) -> Integer -> ConvertResult a
forall a b.
(Ord a, Bounded b, Show a, Show b, Convertible a Integer,
 Convertible b Integer, Typeable a, Typeable b) =>
(a -> ConvertResult b) -> a -> ConvertResult b
boundedConversion Integer -> ConvertResult a
func Integer
i

viaInteger :: (Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
               Typeable a) => SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger :: SqlValue -> (Integer -> a) -> ConvertResult a
viaInteger sv :: SqlValue
sv func :: Integer -> a
func = SqlValue -> (Integer -> ConvertResult a) -> ConvertResult a
forall a.
(Convertible SqlValue a, Bounded a, Show a, Convertible a Integer,
 Typeable a) =>
SqlValue -> (Integer -> ConvertResult a) -> ConvertResult a
viaInteger' SqlValue
sv (a -> ConvertResult a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> ConvertResult a)
-> (Integer -> a) -> Integer -> ConvertResult a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
func)

secs2td :: Integer -> ConvertResult ST.TimeDiff
secs2td :: Integer -> ConvertResult TimeDiff
secs2td x :: Integer
x = Integer -> ConvertResult TimeDiff
forall a b. Convertible a b => a -> ConvertResult b
safeConvert Integer
x


-- | Read a value from a string, and give an informative message
--   if it fails.
read' :: (Typeable a, Read a, Convertible SqlValue a) => String -> ConvertResult a
read' :: String -> ConvertResult a
read' s :: String
s = 
    case ReadS a
forall a. Read a => ReadS a
reads String
s of
      [(x :: a
x,"")] -> a -> ConvertResult a
forall a b. b -> Either a b
Right a
x
      _ -> String -> SqlValue -> ConvertResult a
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError "Cannot read source value as dest type" (String -> SqlValue
SqlString String
s)

#ifdef __HUGS__
parseTime' :: (Typeable t, Convertible SqlValue t) => String -> String -> ConvertResult t
parseTime' _ inpstr =
    convError "Hugs does not support time parsing" (SqlString inpstr)
#else
parseTime' :: (Typeable t, Convertible SqlValue t, ParseTime t) => String -> String -> ConvertResult t
parseTime' :: String -> String -> ConvertResult t
parseTime' fmtstr :: String
fmtstr inpstr :: String
inpstr = 
#if MIN_TIME_15
    case Bool -> TimeLocale -> String -> String -> Maybe t
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
fmtstr String
inpstr of
#else
    case parseTime defaultTimeLocale fmtstr inpstr of
#endif
      Nothing -> String -> SqlValue -> ConvertResult t
forall a b.
(Show a, Typeable a, Typeable b) =>
String -> a -> ConvertResult b
convError ("Cannot parse using default format string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
fmtstr)
                 (String -> SqlValue
SqlString String
inpstr)
      Just x :: t
x -> t -> ConvertResult t
forall a b. b -> Either a b
Right t
x
#endif