postgresql-simple- Mid-Level PostgreSQL client library

MaintainerLeon P Smith <>
Safe HaskellNone



Basic types.



data Null Source

A placeholder for the SQL NULL value.




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

compatible with any data type, but the value must be null

data Default Source

A placeholder for the PostgreSQL DEFAULT value.



newtype Only a Source

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) -> {- ... -}




fromOnly :: a


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 (Maybe (Only a)) 
FromField a => FromRow (Only a) 

newtype In a Source

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


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


In a 


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 Source

Wrap binary data for use as a bytea value.




fromBinary :: a

newtype Identifier Source

Wrap text for use as sql identifier, i.e. a table or column name.



newtype Query Source

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.



newtype Oid


Oid CUInt 

data h :. t Source

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


h :. t 


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 PGArray a Source

Wrap a list for use as a PostgreSQL array.




fromPGArray :: [a]


Functor PGArray 
Typeable1 PGArray 
Eq a => Eq (PGArray a) 
Ord a => Ord (PGArray a) 
Read a => Read (PGArray a) 
Show a => Show (PGArray a) 
ToField a => ToField (PGArray a) 
(FromField a, Typeable a) => FromField (PGArray a)

any postgresql array whose elements are compatible with type a

data Values a Source

Represents a VALUES table literal, usable as an alternative to executeMany and returning. For example:

 execute c "INSERT INTO table (key,val) ?"
      (Only (Values ["int4","text"]

Issues the following query:

 INSERT INTO table (key,val) (VALUES (1::"int4",'hello'::"text"),(2,'world'))

When the list of values is empty, the following query will be issued:

 INSERT INTO table (key,val) (VALUES (null::"int4",null::"text") LIMIT 0)

By contrast, executeMany and returning don't issue the query in the empty case, and simply return 0 and [] respectively.

The advantage over executeMany is in cases when you want to parameterize table literals in addition to other parameters, as can occur with writable common table expressions, for example.

The first argument is a list of postgresql type names. Because this is turned into a properly quoted identifier, the type name is case sensitive and must be as it appears in the pg_type table. Thus, you must write timestamptz instead of timestamp with time zone, int4 instead of integer, _int8 instead of bigint[], etcetera.

You may omit the type names, however, if you do so the list of values must be non-empty, and postgresql must be able to infer the types of the columns from the surrounding context. If these conditions are not met, postgresql-simple will throw an exception without issuing the query in the former case, and in the latter the postgres server will return an error which will be turned into a SqlError exception.

See for more information.


Values [QualifiedIdentifier] [a] 


Typeable1 Values 
Eq a => Eq (Values a) 
Ord a => Ord (Values a) 
Read a => Read (Values a) 
Show a => Show (Values a) 
ToRow a => ToField (Values a)