| Copyright | (c) 2011 MailRank, Inc. (c) 2011-2012 Leon P Smith |
|---|---|
| License | BSD3 |
| Maintainer | Leon P Smith <leon@melding-monads.com> |
| Stability | experimental |
| Safe Haskell | None |
| Language | Haskell98 |
Database.PostgreSQL.Simple.Types
Description
Basic types.
- data Null = Null
- data Default = Default
- newtype Only a = Only {
- fromOnly :: a
- newtype In a = In a
- newtype Binary a = Binary {
- fromBinary :: a
- newtype Identifier = Identifier {}
- data QualifiedIdentifier = QualifiedIdentifier (Maybe Text) Text
- newtype Query = Query {}
- newtype Oid :: * = Oid CUInt
- data h :. t = h :. t
- newtype Savepoint = Savepoint Query
- newtype PGArray a = PGArray {
- fromPGArray :: [a]
- data Values a = Values [QualifiedIdentifier] [a]
Documentation
A placeholder for the SQL NULL value.
Constructors
| Null |
A placeholder for the PostgreSQL DEFAULT value.
Constructors
| Default |
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) -> {- ... -}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 |
newtype Identifier Source
Wrap text for use as sql identifier, i.e. a table or column name.
Constructors
| Identifier | |
Fields | |
data QualifiedIdentifier Source
Wrap text for use as (maybe) qualified identifier, i.e. a table with schema, or column with table.
Constructors
| QualifiedIdentifier (Maybe Text) Text |
Instances
| Eq QualifiedIdentifier Source | |
| Ord QualifiedIdentifier Source | |
| Read QualifiedIdentifier Source | |
| Show QualifiedIdentifier Source | |
| IsString QualifiedIdentifier Source |
|
| Hashable QualifiedIdentifier Source | |
| ToField QualifiedIdentifier 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.
Constructors
| Query | |
Fields | |
newtype Oid :: *
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 infixr 3 |
Wrap a list for use as a PostgreSQL array.
Constructors
| PGArray | |
Fields
| |
Instances
| Functor PGArray Source | |
| Eq a => Eq (PGArray a) Source | |
| Ord a => Ord (PGArray a) Source | |
| Read a => Read (PGArray a) Source | |
| Show a => Show (PGArray a) Source | |
| (FromField a, Typeable * a) => FromField (PGArray a) Source | any postgresql array whose elements are compatible with type |
| ToField a => ToField (PGArray a) Source |
Represents a VALUES table literal, usable as an alternative
to executeMany and returning. The main advantage is that
you can parametrize more than just a single VALUES expression.
For example, here's a query to insert a thing into one table
and some attributes of that thing into another, returning the
new id generated by the database:
query c [sql|
WITH new_thing AS (
INSERT INTO thing (name) VALUES (?) RETURNING id
), new_attributes AS (
INSERT INTO thing_attributes
SELECT new_thing.id, attrs.*
FROM new_thing JOIN ? attrs
) SELECT * FROM new_thing
|] ("foo", Values [ "int4", "text" ]
[ ( 1 , "hello" )
, ( 2 , "world" ) ])(Note this example uses writable common table expressions, which were added in PostgreSQL 9.1)
The second parameter gets expanded into the following SQL syntax:
(VALUES (1::"int4",'hello'::"text"),(2,'world'))
When the list of attributes is empty, the second parameter expands to:
(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.
This behavior is usually correct given their intended use cases,
but would certainly be wrong in the example above.
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 the first
condition is not met, postgresql-simple will throw an exception
without issuing the query. In the second case, the postgres server
will return an error which will be turned into a SqlError exception.
See http://www.postgresql.org/docs/9.3/static/sql-values.html for more information.
Constructors
| Values [QualifiedIdentifier] [a] |