postgresql-simple-0.2.4.1: Mid-Level PostgreSQL client library

Portability | portable
Stability | experimental
Maintainer | Leon P Smith <leon@melding-monads.com>
Safe Haskell | None

Database.PostgreSQL.Simple.Types

Description

Basic types.

Synopsis

- data Null = Null
- newtype Only a = Only {
  - fromOnly :: a
  }
- newtype In a = In a
- newtype Binary a = Binary a
- newtype Query = Query {
  - fromQuery :: ByteString
  }
- newtype Oid = Oid CUInt
- data h :. t = h :. t

# Documentation

data Null

A placeholder for the SQL `NULL` value.

Constructors

Null |

Instances

Eq Null |
Read Null |
Show Null |
Typeable Null |
ToField Null |
FromField Null |

newtype Only a

A single-value "collection".

This is useful if you need to supply a single parameter to a SQL query, or extract a single column from a SQL result.

Parameter example:

    query c "select x from scores where x > ?" (Only (42::Int))

Result example:

    xs <- query_ c "select id from users"
    forM_ xs $ \(Only id) -> {- ... -}

Constructors

Only |

Fields

fromOnly :: a

Instances

Functor Only |
Typeable1 Only |
Eq a => Eq (Only a) |
Ord a => Ord (Only a) |
Read a => Read (Only a) |
Show a => Show (Only a) |
ToField a => ToRow (Only a) |
FromField a => FromRow (Only a) |

newtype In a

Wrap a list of values for use in an `IN` clause. Replaces a single "`?`" character with a parenthesized list of rendered values.

Example:

     query c "select * from whatever where id in ?" (Only (In [3,4,5]))

Constructors

In a |

Instances

Functor In |
Typeable1 In |
Eq a => Eq (In a) |
Ord a => Ord (In a) |
Read a => Read (In a) |
Show a => Show (In a) |
ToField a => ToField (In [a]) |

newtype Binary a

Wrap binary data for use as a `bytea` value.

Constructors

Binary a |

Instances

Functor Binary |
Typeable1 Binary |
Eq a => Eq (Binary a) |
Ord a => Ord (Binary a) |
Read a => Read (Binary a) |
Show a => Show (Binary a) |
ToField (Binary ByteString) |
ToField (Binary ByteString) |
FromField (Binary ByteString) |
FromField (Binary ByteString) |

newtype Query

A query string. This type is intended to make it difficult to construct a SQL query by concatenating string fragments, as that is an extremely common way to accidentally introduce SQL injection vulnerabilities into an application.

This type is an instance of `IsString`, so the easiest way to construct a query is to enable the `OverloadedStrings` language extension and then simply write the query in double quotes.

     {-# LANGUAGE OverloadedStrings #-}

     import Database.PostgreSQL.Simple

     q :: Query
     q = "select ?"

The underlying type is a `ByteString`, and literal Haskell strings that contain Unicode characters will be correctly transformed to UTF-8.

Constructors

Query |

Fields

fromQuery :: ByteString

Instances

Eq Query |
Ord Query |
Read Query |
Show Query |
Typeable Query |
IsString Query |
Monoid Query |

newtype Oid

Constructors

Oid CUInt |

Instances

Eq Oid |
Ord Oid |
Read Oid |
Show Oid |
Storable Oid |
ToField Oid |
FromField Oid |

data h :. t

A composite type to parse your custom data structures without having to define dummy newtype wrappers every time.

     instance FromRow MyData where ...

     instance FromRow MyData2 where ...

then I can do the following for free:

     res <- query' c ...
     forM res $ \(MyData{..} :. MyData2{..}) -> do
       ....

Constructors

h :. t |

Instances

Typeable2 :. |
(Eq h, Eq t) => Eq (:. h t) |
(Ord h, Ord t) => Ord (:. h t) |
(Read h, Read t) => Read (:. h t) |
(Show h, Show t) => Show (:. h t) |
(ToRow a, ToRow b) => ToRow (:. a b) |
(FromRow a, FromRow b) => FromRow (:. a b) |