Database.PostgreSQL.Simple.Types

Basic types.

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

compatible with any data type, but the value must be 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)

bytea

FromField (Binary ByteString)

bytea

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

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)

newtype Savepoint

Constructors

Savepoint Query

Instances

Eq Savepoint

Ord Savepoint

Read Savepoint

Show Savepoint

Typeable Savepoint