Database.PSQL.Types

Documentation

data TablePrefix

Instances

Show TablePrefix

Defined in Database.PSQL.Types

Methods

showsPrec :: Int -> TablePrefix -> ShowS

show :: TablePrefix -> String

showList :: [TablePrefix] -> ShowS

IsString TablePrefix

Defined in Database.PSQL.Types

Methods

fromString :: String -> TablePrefix

type PSQLPool = Pool Connection

type PSQL a = TablePrefix -> Connection -> IO a

class HasPSQL u

Minimal complete definition

psqlPool, tablePrefix

Instances

HasPSQL (SimpleEnv u)

Defined in Database.PSQL.Types

Methods

psqlPool :: SimpleEnv u -> PSQLPool

tablePrefix :: SimpleEnv u -> TablePrefix

psqlPool :: HasPSQL u => u -> PSQLPool

tablePrefix :: HasPSQL u => u -> TablePrefix

data SimpleEnv u

Instances

HasOtherEnv u (SimpleEnv u)

Defined in Database.PSQL.Types

Methods

otherEnv :: SimpleEnv u -> u

HasPSQL (SimpleEnv u)

Defined in Database.PSQL.Types

Methods

psqlPool :: SimpleEnv u -> PSQLPool

tablePrefix :: SimpleEnv u -> TablePrefix

simpleEnv :: Pool Connection -> TablePrefix -> u -> SimpleEnv u

class HasOtherEnv u a

Minimal complete definition

otherEnv

Instances

HasOtherEnv u (SimpleEnv u)

Defined in Database.PSQL.Types

Methods

otherEnv :: SimpleEnv u -> u

otherEnv :: HasOtherEnv u a => a -> u

data TableName

Instances

Show TableName

Defined in Database.PSQL.Types

Methods

showsPrec :: Int -> TableName -> ShowS

show :: TableName -> String

showList :: [TableName] -> ShowS

IsString TableName

Defined in Database.PSQL.Types

Methods

fromString :: String -> TableName

getTableName :: TablePrefix -> TableName -> String

type Columns = [Column]

createTable :: TableName -> Columns -> PSQL Int64

constraintPrimaryKey :: TablePrefix -> TableName -> Columns -> Column

getIndexName :: TablePrefix -> TableName -> IndexName -> String

data IndexName

Instances

Show IndexName

Defined in Database.PSQL.Types

Methods

showsPrec :: Int -> IndexName -> ShowS

show :: IndexName -> String

showList :: [IndexName] -> ShowS

IsString IndexName

Defined in Database.PSQL.Types

Methods

fromString :: String -> IndexName

createIndex :: Bool -> TableName -> IndexName -> Columns -> PSQL Int64

getOnly :: FromRow (Only a) => [Only a] -> Maybe a

getOnlyDefault :: FromRow (Only a) => a -> [Only a] -> a

insert :: ToRow a => TableName -> Columns -> a -> PSQL Int64

insertRet :: (ToRow a, FromRow (Only b)) => TableName -> Columns -> Column -> a -> b -> PSQL b

insertOrUpdate :: ToRow a => TableName -> Columns -> Columns -> Columns -> a -> PSQL Int64

update :: ToRow a => TableName -> Columns -> String -> a -> PSQL Int64

delete :: ToRow a => TableName -> String -> a -> PSQL Int64

delete_ :: TableName -> PSQL Int64

count :: ToRow a => TableName -> String -> a -> PSQL Int64

count_ :: TableName -> PSQL Int64

select :: (ToRow a, FromRow b) => TableName -> Columns -> String -> a -> From -> Size -> OrderBy -> PSQL [b]

selectOnly :: (ToRow a, FromRow (Only b)) => TableName -> Column -> String -> a -> From -> Size -> OrderBy -> PSQL [b]

select_ :: FromRow b => TableName -> Columns -> From -> Size -> OrderBy -> PSQL [b]

selectOnly_ :: FromRow (Only b) => TableName -> Column -> From -> Size -> OrderBy -> PSQL [b]

selectOne :: (ToRow a, FromRow b) => TableName -> Columns -> String -> a -> PSQL (Maybe b)

selectOneOnly :: (ToRow a, FromRow (Only b)) => TableName -> Column -> String -> a -> PSQL (Maybe b)

type VersionList a = [Version a]

mergeDatabase :: VersionList a -> PSQL ()

class FromRow a where

A collection type that can be converted from a sequence of fields. Instances are provided for tuples up to 10 elements and lists of any length.

Note that instances can be defined outside of postgresql-simple, which is often useful. For example, here's an instance for a user-defined pair:

data User = User { name :: String, fileQuota :: Int }

instance FromRow User where
    fromRow = User <$> field <*> field

The number of calls to field must match the number of fields returned in a single row of the query result. Otherwise, a ConversionFailed exception will be thrown.

You can also derive FromRow for your data type using GHC generics, like this:

{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric  #-}

import GHC.Generics (Generic)
import Database.PostgreSQL.Simple (FromRow)

data User = User { name :: String, fileQuota :: Int }
  deriving (Generic, FromRow)

Note that this only works for product types (e.g. records) and does not support sum types or recursive types.

Note that field evaluates its result to WHNF, so the caveats listed in mysql-simple and very early versions of postgresql-simple no longer apply. Instead, look at the caveats associated with user-defined implementations of fromField.

Minimal complete definition

Nothing

Methods

fromRow :: RowParser a

Instances

FromField a => FromRow [a]

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser [a]

FromField a => FromRow (Maybe [a])

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe [a])

(FromField a, FromField b) => FromRow (Maybe (a, b))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b))

(FromField a, FromField b, FromField c) => FromRow (Maybe (a, b, c))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c))

(FromField a, FromField b, FromField c, FromField d) => FromRow (Maybe (a, b, c, d))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d))

(FromField a, FromField b, FromField c, FromField d, FromField e) => FromRow (Maybe (a, b, c, d, e))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f) => FromRow (Maybe (a, b, c, d, e, f))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g) => FromRow (Maybe (a, b, c, d, e, f, g))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h) => FromRow (Maybe (a, b, c, d, e, f, g, h))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i) => FromRow (Maybe (a, b, c, d, e, f, g, h, i))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r, FromField s) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r, FromField s, FromField t) => FromRow (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))

FromField a => FromRow (Maybe (Only a))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (Only a))

FromField a => FromRow (Maybe (Vector a))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (Vector a))

FromField a => FromRow (Only a)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Only a)

FromField a => FromRow (Vector a)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Vector a)

(FromField a, FromField b) => FromRow (a, b)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b)

(FromRow a, FromRow b) => FromRow (a :. b)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a :. b)

(FromField a, FromField b, FromField c) => FromRow (a, b, c)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c)

(FromField a, FromField b, FromField c, FromField d) => FromRow (a, b, c, d)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d)

(FromField a, FromField b, FromField c, FromField d, FromField e) => FromRow (a, b, c, d, e)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f) => FromRow (a, b, c, d, e, f)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g) => FromRow (a, b, c, d, e, f, g)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h) => FromRow (a, b, c, d, e, f, g, h)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i) => FromRow (a, b, c, d, e, f, g, h, i)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j) => FromRow (a, b, c, d, e, f, g, h, i, j)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k) => FromRow (a, b, c, d, e, f, g, h, i, j, k)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r, FromField s) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

(FromField a, FromField b, FromField c, FromField d, FromField e, FromField f, FromField g, FromField h, FromField i, FromField j, FromField k, FromField l, FromField m, FromField n, FromField o, FromField p, FromField q, FromField r, FromField s, FromField t) => FromRow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

field :: FromField a => RowParser a

newtype Only a

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

Functor Only

Defined in Data.Tuple.Only

Methods

fmap :: (a -> b) -> Only a -> Only b

(<$) :: a -> Only b -> Only a

Eq a => Eq (Only a)

Defined in Data.Tuple.Only

Methods

(==) :: Only a -> Only a -> Bool

(/=) :: Only a -> Only a -> Bool

Data a => Data (Only a)

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)

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

toConstr :: Only a -> Constr

dataTypeOf :: Only a -> DataType

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Only a)

Defined in Data.Tuple.Only

Methods

compare :: Only a -> Only a -> Ordering

(<) :: Only a -> Only a -> Bool

(<=) :: Only a -> Only a -> Bool

(>) :: Only a -> Only a -> Bool

(>=) :: Only a -> Only a -> Bool

max :: Only a -> Only a -> Only a

min :: Only a -> Only a -> Only a

Read a => Read (Only a)

Defined in Data.Tuple.Only

Methods

readsPrec :: Int -> ReadS (Only a)

readList :: ReadS [Only a]

readPrec :: ReadPrec (Only a)

readListPrec :: ReadPrec [Only a]

Show a => Show (Only a)

Defined in Data.Tuple.Only

Methods

showsPrec :: Int -> Only a -> ShowS

show :: Only a -> String

showList :: [Only a] -> ShowS

Generic (Only a)

Defined in Data.Tuple.Only

Associated Types

type Rep (Only a) :: Type -> Type

Methods

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

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

NFData a => NFData (Only a)

Defined in Data.Tuple.Only

Methods

rnf :: Only a -> ()

FromField a => FromRow (Maybe (Only a))

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Maybe (Only a))

FromField a => FromRow (Only a)

Defined in Database.PostgreSQL.Simple.FromRow

Methods

fromRow :: RowParser (Only a)

ToField a => ToRow (Only a)

Defined in Database.PostgreSQL.Simple.ToRow

Methods

toRow :: Only a -> [Action]

type Rep (Only a)

Defined in Data.Tuple.Only

type Rep (Only a) = D1 (MetaData "Only" "Data.Tuple.Only" "Only-0.1-4eYnxvcrr7tEbYgCvIkHLb" True) (C1 (MetaCons "Only" PrefixI True) (S1 (MetaSel (Just "fromOnly") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data SqlError

Constructors

SqlError

Fields

• sqlState :: ByteString
• sqlExecStatus :: ExecStatus
• sqlErrorMsg :: ByteString
• sqlErrorDetail :: ByteString
• sqlErrorHint :: ByteString

Instances

Eq SqlError

Defined in Database.PostgreSQL.Simple.Internal

Methods

(==) :: SqlError -> SqlError -> Bool

(/=) :: SqlError -> SqlError -> Bool

Show SqlError

Defined in Database.PostgreSQL.Simple.Internal

Methods

showsPrec :: Int -> SqlError -> ShowS

show :: SqlError -> String

showList :: [SqlError] -> ShowS

Exception SqlError

Defined in Database.PostgreSQL.Simple.Internal

Methods

toException :: SqlError -> SomeException

fromException :: SomeException -> Maybe SqlError

displayException :: SqlError -> String

data OrderBy

Instances

Eq OrderBy

Defined in Database.PSQL.Types

Methods

(==) :: OrderBy -> OrderBy -> Bool

(/=) :: OrderBy -> OrderBy -> Bool

Show OrderBy

Defined in Database.PSQL.Types

Methods

showsPrec :: Int -> OrderBy -> ShowS

show :: OrderBy -> String

showList :: [OrderBy] -> ShowS

Generic OrderBy

Defined in Database.PSQL.Types

Associated Types

type Rep OrderBy :: Type -> Type

Methods

from :: OrderBy -> Rep OrderBy x

to :: Rep OrderBy x -> OrderBy

Hashable OrderBy

Defined in Database.PSQL.Types

Methods

hashWithSalt :: Int -> OrderBy -> Int

hash :: OrderBy -> Int

type Rep OrderBy

Defined in Database.PSQL.Types

type Rep OrderBy = D1 (MetaData "OrderBy" "Database.PSQL.Types" "psql-utils-0.1.0.0-Ej4o64DLpxDHoGExh4ju3h" False) (C1 (MetaCons "Desc" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: (C1 (MetaCons "Asc" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "None" PrefixI False) (U1 :: Type -> Type)))

asc :: String -> OrderBy

desc :: String -> OrderBy

none :: OrderBy