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

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 | Haskell2010

Database.PostgreSQL.Simple.Types

Description

Basic types.

Synopsis

- 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 {
  - fromIdentifier :: Text
  }
- data QualifiedIdentifier = QualifiedIdentifier (Maybe Text) Text
- newtype Query = Query {
  - fromQuery :: ByteString
  }
- 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

data Null Source #

A placeholder for the SQL `NULL` value.

Constructors

Null |

#### Instances

Instances details

Read Null Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS Null Source # readList :: ReadS [Null] Source # readPrec :: ReadPrec Null Source # readListPrec :: ReadPrec [Null] Source #
Show Null Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Null -> ShowS Source # show :: Null -> String Source # showList :: [Null] -> ShowS Source #
FromField Null Source # | compatible with any data type, but the value must be null
Instance details Defined in Database.PostgreSQL.Simple.FromField Methods fromField :: FieldParser Null Source #
ToField Null Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Null -> Action Source #

data Default Source #

A placeholder for the PostgreSQL `DEFAULT` value.

Constructors

Default |

#### Instances

Instances details

Read Default Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS Default Source # readList :: ReadS [Default] Source # readPrec :: ReadPrec Default Source # readListPrec :: ReadPrec [Default] Source #
Show Default Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Default -> ShowS Source # show :: Default -> String Source # showList :: [Default] -> ShowS Source #
ToField Default Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Default -> Action Source #

newtype Only a Source #

The 1-tuple type or single-value "collection".

This type is structurally equivalent to the `Identity` type, but its intent is more about serving as the anonymous 1-tuple type missing from Haskell for attaching typeclass instances.

Parameter usage example:

    encodeSomething (Only (42::Int))

Result usage example:

    xs <- decodeSomething
    forM_ xs $ \(Only id) -> {- ... -}

Constructors

Only |

Fields

- fromOnly :: a

#### Instances

Instances details

Functor Only |
Instance details Defined in Data.Tuple.Only Methods fmap :: (a -> b) -> Only a -> Only b Source # (<$) :: a -> Only b -> Only a Source #
NFData a => NFData (Only a) |
Instance details Defined in Data.Tuple.Only Methods rnf :: Only a -> () Source #
Data a => Data (Only a) |

Instance details

Defined in Data.Tuple.Only

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Only a -> c (Only a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Only a) Source #

toConstr :: Only a -> Constr Source #

dataTypeOf :: Only a -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Only a)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Only a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Only a -> Only a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Only a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Only a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) Source #

Generic (Only a) |

Instance details

Defined in Data.Tuple.Only

Associated Types

type Rep (Only a) |
Instance details Defined in Data.Tuple.Only type Rep (Only a) = D1 ('MetaData "Only" "Data.Tuple.Only" "Only-0.1-3GozSrXszIj1AVdRsJpLBH" 'True) (C1 ('MetaCons "Only" 'PrefixI 'True) (S1 ('MetaSel ('Just "fromOnly") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: Only a -> Rep (Only a) x Source #

to :: Rep (Only a) x -> Only a Source #

Read a => Read (Only a) |
Instance details Defined in Data.Tuple.Only Methods readsPrec :: Int -> ReadS (Only a) Source # readList :: ReadS [Only a] Source # readPrec :: ReadPrec (Only a) Source # readListPrec :: ReadPrec [Only a] Source #
Show a => Show (Only a) |
Instance details Defined in Data.Tuple.Only Methods showsPrec :: Int -> Only a -> ShowS Source # show :: Only a -> String Source # showList :: [Only a] -> ShowS Source #
Eq a => Eq (Only a) |
Instance details Defined in Data.Tuple.Only Methods (==) :: Only a -> Only a -> Bool Source # (/=) :: Only a -> Only a -> Bool Source #
Ord a => Ord (Only a) |
Instance details Defined in Data.Tuple.Only Methods compare :: Only a -> Only a -> Ordering Source # (<) :: Only a -> Only a -> Bool Source # (<=) :: Only a -> Only a -> Bool Source # (>) :: Only a -> Only a -> Bool Source # (>=) :: Only a -> Only a -> Bool Source # max :: Only a -> Only a -> Only a Source # min :: Only a -> Only a -> Only a Source #
FromField a => FromRow (Only a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.FromRow Methods fromRow :: RowParser (Only a) Source #
FromField a => FromRow (Maybe (Only a)) Source # |
Instance details Defined in Database.PostgreSQL.Simple.FromRow Methods fromRow :: RowParser (Maybe (Only a)) Source #
ToField a => ToRow (Only a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToRow Methods toRow :: Only a -> [Action] Source #
type Rep (Only a) |
Instance details Defined in Data.Tuple.Only type Rep (Only a) = D1 ('MetaData "Only" "Data.Tuple.Only" "Only-0.1-3GozSrXszIj1AVdRsJpLBH" 'True) (C1 ('MetaCons "Only" 'PrefixI 'True) (S1 ('MetaSel ('Just "fromOnly") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 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.

Example:

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

Note that `In []` expands to `(null)`, which works as expected in the query above, but evaluates to the logical null value on every row instead of `TRUE`. This means that changing the query above to `... id NOT in ?` and supplying the empty list as the parameter returns zero rows, instead of all of them as one would expect.

Since postgresql doesn't seem to provide a syntax for actually specifying an empty list, which could solve this completely, there are two workarounds particularly worth mentioning, namely:

1. Use postgresql-simple's `Values` type instead, which can handle the empty case correctly. Note however that while specifying the postgresql type `"int4"` is mandatory in the empty case, specifying the haskell type `Values (Only Int)` would not normally be needed in realistic use cases.

       query c "select * from whatever where id not in ?"
               (Only (Values ["int4"] [] :: Values (Only Int)))

2. Use sql's `COALESCE` operator to turn a logical `null` into the correct boolean. Note however that the correct boolean depends on the use case:

       query c "select * from whatever where coalesce(id NOT in ?, TRUE)"
               (Only (In [] :: In [Int]))

       query c "select * from whatever where coalesce(id IN ?, FALSE)"
               (Only (In [] :: In [Int]))

   Note that at as of PostgreSQL 9.4, the query planner cannot see inside the `COALESCE` operator, so if you have an index on `id` then you probably don't want to write the last example with `COALESCE`, which would result in a table scan. There are further caveats if `id` can be null or you want null treated sensibly as a component of `IN` or `NOT IN`.

Constructors

In a |

#### Instances

Instances details

Functor In Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fmap :: (a -> b) -> In a -> In b Source # (<$) :: a -> In b -> In a Source #
Read a => Read (In a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS (In a) Source # readList :: ReadS [In a] Source # readPrec :: ReadPrec (In a) Source # readListPrec :: ReadPrec [In a] Source #
Show a => Show (In a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> In a -> ShowS Source # show :: In a -> String Source # showList :: [In a] -> ShowS Source #
Eq a => Eq (In a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: In a -> In a -> Bool Source # (/=) :: In a -> In a -> Bool Source #
Ord a => Ord (In a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods compare :: In a -> In a -> Ordering Source # (<) :: In a -> In a -> Bool Source # (<=) :: In a -> In a -> Bool Source # (>) :: In a -> In a -> Bool Source # (>=) :: In a -> In a -> Bool Source # max :: In a -> In a -> In a Source # min :: In a -> In a -> In a Source #
ToField a => ToField (In [a]) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: In [a] -> Action Source #

newtype Binary a Source #

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

Constructors

Binary |

Fields

- fromBinary :: a

#### Instances

Instances details

Functor Binary Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fmap :: (a -> b) -> Binary a -> Binary b Source # (<$) :: a -> Binary b -> Binary a Source #
Read a => Read (Binary a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS (Binary a) Source # readList :: ReadS [Binary a] Source # readPrec :: ReadPrec (Binary a) Source # readListPrec :: ReadPrec [Binary a] Source #
Show a => Show (Binary a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Binary a -> ShowS Source # show :: Binary a -> String Source # showList :: [Binary a] -> ShowS Source #
Eq a => Eq (Binary a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: Binary a -> Binary a -> Bool Source # (/=) :: Binary a -> Binary a -> Bool Source #
Ord a => Ord (Binary a) Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: Binary a -> Binary a -> Ordering Source #

(<) :: Binary a -> Binary a -> Bool Source #

(<=) :: Binary a -> Binary a -> Bool Source #

(>) :: Binary a -> Binary a -> Bool Source #

(>=) :: Binary a -> Binary a -> Bool Source #

max :: Binary a -> Binary a -> Binary a Source #

min :: Binary a -> Binary a -> Binary a Source #

FromField (Binary ByteString) Source # | bytea
Instance details Defined in Database.PostgreSQL.Simple.FromField Methods fromField :: FieldParser (Binary ByteString) Source #
FromField (Binary ByteString) Source # | bytea
Instance details Defined in Database.PostgreSQL.Simple.FromField Methods fromField :: FieldParser (Binary ByteString) Source #
ToField (Binary ByteString) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Binary ByteString -> Action Source #
ToField (Binary ByteString) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Binary ByteString -> Action Source #

newtype Identifier Source #

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

Constructors

Identifier |

Fields

- fromIdentifier :: Text

#### Instances

Instances details

IsString Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fromString :: String -> Identifier Source #
Read Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS Identifier Source # readList :: ReadS [Identifier] Source # readPrec :: ReadPrec Identifier Source # readListPrec :: ReadPrec [Identifier] Source #
Show Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Identifier -> ShowS Source # show :: Identifier -> String Source # showList :: [Identifier] -> ShowS Source #
Eq Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: Identifier -> Identifier -> Bool Source # (/=) :: Identifier -> Identifier -> Bool Source #
Ord Identifier Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: Identifier -> Identifier -> Ordering Source #

(<) :: Identifier -> Identifier -> Bool Source #

(<=) :: Identifier -> Identifier -> Bool Source #

(>) :: Identifier -> Identifier -> Bool Source #

(>=) :: Identifier -> Identifier -> Bool Source #

max :: Identifier -> Identifier -> Identifier Source #

min :: Identifier -> Identifier -> Identifier Source #

Hashable Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods hashWithSalt :: Int -> Identifier -> Int Source # hash :: Identifier -> Int Source #
ToField Identifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Identifier -> Action Source #

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

Instances details

IsString QualifiedIdentifier Source # | `"foo.bar"` will get turned into `QualifiedIdentifier (Just "foo") "bar"`, while `"foo"` will get turned into `QualifiedIdentifier Nothing "foo"`. Note this instance is for convenience, and does not match postgres syntax. It only examines the first period character, and thus cannot be used if the qualifying identifier contains a period for example.
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fromString :: String -> QualifiedIdentifier Source #
Read QualifiedIdentifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS QualifiedIdentifier Source # readList :: ReadS [QualifiedIdentifier] Source # readPrec :: ReadPrec QualifiedIdentifier Source # readListPrec :: ReadPrec [QualifiedIdentifier] Source #
Show QualifiedIdentifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> QualifiedIdentifier -> ShowS Source # show :: QualifiedIdentifier -> String Source # showList :: [QualifiedIdentifier] -> ShowS Source #
Eq QualifiedIdentifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source # (/=) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source #
Ord QualifiedIdentifier Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: QualifiedIdentifier -> QualifiedIdentifier -> Ordering Source #

(<) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source #

(<=) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source #

(>) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source #

(>=) :: QualifiedIdentifier -> QualifiedIdentifier -> Bool Source #

max :: QualifiedIdentifier -> QualifiedIdentifier -> QualifiedIdentifier Source #

min :: QualifiedIdentifier -> QualifiedIdentifier -> QualifiedIdentifier Source #

Hashable QualifiedIdentifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods hashWithSalt :: Int -> QualifiedIdentifier -> Int Source # hash :: QualifiedIdentifier -> Int Source #
ToField QualifiedIdentifier Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: QualifiedIdentifier -> Action Source #

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.

Constructors

Query |

Fields

- fromQuery :: ByteString

#### Instances

Instances details

Monoid Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods mempty :: Query Source # mappend :: Query -> Query -> Query Source # mconcat :: [Query] -> Query Source #
Semigroup Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (<>) :: Query -> Query -> Query Source # sconcat :: NonEmpty Query -> Query Source # stimes :: Integral b => b -> Query -> Query Source #
IsString Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fromString :: String -> Query Source #
Read Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS Query Source # readList :: ReadS [Query] Source # readPrec :: ReadPrec Query Source # readListPrec :: ReadPrec [Query] Source #
Show Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Query -> ShowS Source # show :: Query -> String Source # showList :: [Query] -> ShowS Source #
Eq Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: Query -> Query -> Bool Source # (/=) :: Query -> Query -> Bool Source #
Ord Query Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods compare :: Query -> Query -> Ordering Source # (<) :: Query -> Query -> Bool Source # (<=) :: Query -> Query -> Bool Source # (>) :: Query -> Query -> Bool Source # (>=) :: Query -> Query -> Bool Source # max :: Query -> Query -> Query Source # min :: Query -> Query -> Query Source #

newtype Oid Source #

Constructors

Oid CUInt |

#### Instances

Instances details

Storable Oid |

Instance details

Defined in Database.PostgreSQL.LibPQ.Oid

Methods

sizeOf :: Oid -> Int Source #

alignment :: Oid -> Int Source #

peekElemOff :: Ptr Oid -> Int -> IO Oid Source #

pokeElemOff :: Ptr Oid -> Int -> Oid -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Oid Source #

pokeByteOff :: Ptr b -> Int -> Oid -> IO () Source #

peek :: Ptr Oid -> IO Oid Source #

poke :: Ptr Oid -> Oid -> IO () Source #

Read Oid |
Instance details Defined in Database.PostgreSQL.LibPQ.Oid Methods readsPrec :: Int -> ReadS Oid Source # readList :: ReadS [Oid] Source # readPrec :: ReadPrec Oid Source # readListPrec :: ReadPrec [Oid] Source #
Show Oid |
Instance details Defined in Database.PostgreSQL.LibPQ.Oid Methods showsPrec :: Int -> Oid -> ShowS Source # show :: Oid -> String Source # showList :: [Oid] -> ShowS Source #
Eq Oid |
Instance details Defined in Database.PostgreSQL.LibPQ.Oid Methods (==) :: Oid -> Oid -> Bool Source # (/=) :: Oid -> Oid -> Bool Source #
Ord Oid |
Instance details Defined in Database.PostgreSQL.LibPQ.Oid Methods compare :: Oid -> Oid -> Ordering Source # (<) :: Oid -> Oid -> Bool Source # (<=) :: Oid -> Oid -> Bool Source # (>) :: Oid -> Oid -> Bool Source # (>=) :: Oid -> Oid -> Bool Source # max :: Oid -> Oid -> Oid Source # min :: Oid -> Oid -> Oid Source #
FromField Oid Source # | oid
Instance details Defined in Database.PostgreSQL.Simple.FromField Methods fromField :: FieldParser Oid Source #
ToField Oid Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Oid -> Action Source #

data h :. t infixr 3 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
      ....

Constructors

h :. t infixr 3 |

#### Instances

Instances details

(Read h, Read t) => Read (h :. t) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS (h :. t) Source # readList :: ReadS [h :. t] Source # readPrec :: ReadPrec (h :. t) Source # readListPrec :: ReadPrec [h :. t] Source #
(Show h, Show t) => Show (h :. t) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> (h :. t) -> ShowS Source # show :: (h :. t) -> String Source # showList :: [h :. t] -> ShowS Source #
(Eq h, Eq t) => Eq (h :. t) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: (h :. t) -> (h :. t) -> Bool Source # (/=) :: (h :. t) -> (h :. t) -> Bool Source #
(Ord h, Ord t) => Ord (h :. t) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods compare :: (h :. t) -> (h :. t) -> Ordering Source # (<) :: (h :. t) -> (h :. t) -> Bool Source # (<=) :: (h :. t) -> (h :. t) -> Bool Source # (>) :: (h :. t) -> (h :. t) -> Bool Source # (>=) :: (h :. t) -> (h :. t) -> Bool Source # max :: (h :. t) -> (h :. t) -> h :. t Source # min :: (h :. t) -> (h :. t) -> h :. t Source #
(FromRow a, FromRow b) => FromRow (a :. b) Source # |
Instance details Defined in Database.PostgreSQL.Simple.FromRow Methods fromRow :: RowParser (a :. b) Source #
(ToRow a, ToRow b) => ToRow (a :. b) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToRow Methods toRow :: (a :. b) -> [Action] Source #

newtype Savepoint Source #

Constructors

Savepoint Query |

#### Instances

Instances details

Read Savepoint Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS Savepoint Source # readList :: ReadS [Savepoint] Source # readPrec :: ReadPrec Savepoint Source # readListPrec :: ReadPrec [Savepoint] Source #
Show Savepoint Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Savepoint -> ShowS Source # show :: Savepoint -> String Source # showList :: [Savepoint] -> ShowS Source #
Eq Savepoint Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: Savepoint -> Savepoint -> Bool Source # (/=) :: Savepoint -> Savepoint -> Bool Source #
Ord Savepoint Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: Savepoint -> Savepoint -> Ordering Source #

(<) :: Savepoint -> Savepoint -> Bool Source #

(<=) :: Savepoint -> Savepoint -> Bool Source #

(>) :: Savepoint -> Savepoint -> Bool Source #

(>=) :: Savepoint -> Savepoint -> Bool Source #

max :: Savepoint -> Savepoint -> Savepoint Source #

min :: Savepoint -> Savepoint -> Savepoint Source #

newtype PGArray a Source #

Wrap a list for use as a PostgreSQL array.

Constructors

PGArray |

Fields

- fromPGArray :: [a]

#### Instances

Instances details

Functor PGArray Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods fmap :: (a -> b) -> PGArray a -> PGArray b Source # (<$) :: a -> PGArray b -> PGArray a Source #
Read a => Read (PGArray a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS (PGArray a) Source # readList :: ReadS [PGArray a] Source # readPrec :: ReadPrec (PGArray a) Source # readListPrec :: ReadPrec [PGArray a] Source #
Show a => Show (PGArray a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> PGArray a -> ShowS Source # show :: PGArray a -> String Source # showList :: [PGArray a] -> ShowS Source #
Eq a => Eq (PGArray a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: PGArray a -> PGArray a -> Bool Source # (/=) :: PGArray a -> PGArray a -> Bool Source #
Ord a => Ord (PGArray a) Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: PGArray a -> PGArray a -> Ordering Source #

(<) :: PGArray a -> PGArray a -> Bool Source #

(<=) :: PGArray a -> PGArray a -> Bool Source #

(>) :: PGArray a -> PGArray a -> Bool Source #

(>=) :: PGArray a -> PGArray a -> Bool Source #

max :: PGArray a -> PGArray a -> PGArray a Source #

min :: PGArray a -> PGArray a -> PGArray a Source #

(FromField a, Typeable a) => FromField (PGArray a) Source # | any postgresql array whose elements are compatible with type `a`
Instance details Defined in Database.PostgreSQL.Simple.FromField Methods fromField :: FieldParser (PGArray a) Source #
ToField a => ToField (PGArray a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: PGArray a -> Action Source #

data Values 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 ON TRUE
        ) 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` or `serial`, `_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 https://www.postgresql.org/docs/9.5/static/sql-values.html for more information.

Constructors

Values [QualifiedIdentifier] [a] |

#### Instances

Instances details

Read a => Read (Values a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods readsPrec :: Int -> ReadS (Values a) Source # readList :: ReadS [Values a] Source # readPrec :: ReadPrec (Values a) Source # readListPrec :: ReadPrec [Values a] Source #
Show a => Show (Values a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods showsPrec :: Int -> Values a -> ShowS Source # show :: Values a -> String Source # showList :: [Values a] -> ShowS Source #
Eq a => Eq (Values a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.Types Methods (==) :: Values a -> Values a -> Bool Source # (/=) :: Values a -> Values a -> Bool Source #
Ord a => Ord (Values a) Source # |

Instance details

Defined in Database.PostgreSQL.Simple.Types

Methods

compare :: Values a -> Values a -> Ordering Source #

(<) :: Values a -> Values a -> Bool Source #

(<=) :: Values a -> Values a -> Bool Source #

(>) :: Values a -> Values a -> Bool Source #

(>=) :: Values a -> Values a -> Bool Source #

max :: Values a -> Values a -> Values a Source #

min :: Values a -> Values a -> Values a Source #

ToRow a => ToField (Values a) Source # |
Instance details Defined in Database.PostgreSQL.Simple.ToField Methods toField :: Values a -> Action Source #