Copyright |
(c) 2011 MailRank Inc.
(c) 2011-2012 Leon P Smith (c) 2012-2013 Janne Hellsten |
---|---|
License | BSD3 |
Maintainer | Janne Hellsten <jjhellst@gmail.com> |
Portability | portable |
Safe Haskell | None |
Language | Haskell2010 |
The
FromField
typeclass, for converting a single value in a row
returned by a SQL query into a more useful Haskell representation.
A Haskell numeric type is considered to be compatible with all
SQLite numeric types that are less accurate than it. For instance,
the Haskell
Double
type is compatible with the SQLite's 32-bit
Int
type because it can represent a
Int
exactly. On the other hand,
since a
Double
might lose precision if representing a 64-bit
BigInt
,
the two are
not
considered compatible.
Synopsis
-
class
FromField
a
where
- fromField :: FieldParser a
- type FieldParser a = Field -> Ok a
-
data
ResultError
-
=
Incompatible
{
- errSQLType :: String
- errHaskellType :: String
- errMessage :: String
-
|
UnexpectedNull
{
- errSQLType :: String
- errHaskellType :: String
- errMessage :: String
-
|
ConversionFailed
{
- errSQLType :: String
- errHaskellType :: String
- errMessage :: String
-
=
Incompatible
{
- data Field
- fieldData :: Field -> SQLData
- returnError :: forall a err. ( Typeable a, Exception err) => ( String -> String -> String -> err) -> Field -> String -> Ok a
Documentation
class FromField a where Source #
A type that may be converted from a SQL type.
fromField :: FieldParser a Source #
Convert a SQL value to a Haskell value.
Returns a list of exceptions if the conversion fails. In the case of
library instances, this will usually be a single
ResultError
, but
may be a
UnicodeException
.
Implementations of
fromField
should not retain any references to
the
Field
nor the
ByteString
arguments after the result has
been evaluated to WHNF. Such a reference causes the entire
LibPQ.
to be retained.
Result
For example, the instance for
ByteString
uses
copy
to avoid
such a reference, and that using bytestring functions such as
drop
and
takeWhile
alone will also trigger this memory leak.
Instances
type FieldParser a = Field -> Ok a Source #
data ResultError Source #
Exception thrown if conversion from a SQL value to a Haskell value fails.
Incompatible |
The SQL and Haskell types are not compatible. |
|
|
UnexpectedNull |
A SQL
|
|
|
ConversionFailed |
The SQL value could not be parsed, or could not be represented as a valid Haskell value, or an unexpected low-level error occurred (e.g. mismatch between metadata and actual data in a row). |
|
Instances
Eq ResultError Source # | |
Defined in Database.SQLite.Simple.FromField (==) :: ResultError -> ResultError -> Bool Source # (/=) :: ResultError -> ResultError -> Bool Source # |
|
Show ResultError Source # | |
Defined in Database.SQLite.Simple.FromField |
|
Exception ResultError Source # | |
Defined in Database.SQLite.Simple.FromField toException :: ResultError -> SomeException Source # fromException :: SomeException -> Maybe ResultError Source # displayException :: ResultError -> String Source # |
fieldData :: Field -> SQLData Source #
Return the actual SQL data for a database field. This allows
user-defined
FromField
instances to access the SQL data
associated with a field being parsed.
returnError :: forall a err. ( Typeable a, Exception err) => ( String -> String -> String -> err) -> Field -> String -> Ok a Source #
Given one of the constructors from
ResultError
, the field,
and an
errMessage
, this fills in the other fields in the
exception value and returns it in a 'Left . SomeException'
constructor.