Database.PostgreSQL.Query.Types

Query execution

class MonadBase IO m => HasPostgres m where

Instances of this typeclass can acquire connection and pass it to computation. It can be reader of pool of connections or just reader of connection

Methods

withPGConnection :: (Connection -> m a) -> m a

Instances

HasPostgres m => HasPostgres (IdentityT m)

HasPostgres m => HasPostgres (MaybeT m)

MonadBase IO m => HasPostgres (PgMonadT m)

(HasPostgres m, Monoid w) => HasPostgres (WriterT w m)

(HasPostgres m, Monoid w) => HasPostgres (WriterT w m)

HasPostgres m => HasPostgres (StateT s m)

HasPostgres m => HasPostgres (StateT s m)

HasPostgres m => HasPostgres (ReaderT r m)

HasPostgres m => HasPostgres (EitherT e m)

(MonadBase IO m, MonadBaseControl IO m, HGetable els (Pool Connection)) => HasPostgres (HReaderT els m)

HasPostgres m => HasPostgres (ContT r m)

HasPostgres m => HasPostgres (ExceptT e m)

class TransactionSafe m

Empty typeclass signing monad in which transaction is safe. i.e. PgMonadT have this instance, but some other monad giving connection from e.g. connection pool is not.

Instances

TransactionSafe m => TransactionSafe (IdentityT m)

TransactionSafe m => TransactionSafe (MaybeT m)

TransactionSafe (PgMonadT m)

(TransactionSafe m, Monoid w) => TransactionSafe (WriterT w m)

(TransactionSafe m, Monoid w) => TransactionSafe (WriterT w m)

TransactionSafe m => TransactionSafe (StateT s m)

TransactionSafe m => TransactionSafe (StateT s m)

TransactionSafe m => TransactionSafe (ReaderT r m)

TransactionSafe m => TransactionSafe (EitherT e m)

TransactionSafe m => TransactionSafe (ContT r m)

TransactionSafe m => TransactionSafe (ExceptT e m)

newtype PgMonadT m a

Reader of connection. Has instance of HasPostgres. So if you have a connection you can run queries in this monad using runPgMonadT. Or you can use this transformer to run sequence of queries using same connection with launchPG.

Constructors

PgMonadT

Fields

unPgMonadT :: ReaderT Connection m a

Instances

MonadTrans PgMonadT

MonadTransControl PgMonadT

MonadBaseControl b m => MonadBaseControl b (PgMonadT m)

MonadBase b m => MonadBase b (PgMonadT m)

MonadError e m => MonadError e (PgMonadT m)

MonadReader r m => MonadReader r (PgMonadT m)

MonadState s m => MonadState s (PgMonadT m)

MonadWriter w m => MonadWriter w (PgMonadT m)

Alternative m => Alternative (PgMonadT m)

Monad m => Monad (PgMonadT m)

Functor m => Functor (PgMonadT m)

MonadFix m => MonadFix (PgMonadT m)

MonadPlus m => MonadPlus (PgMonadT m)

Applicative m => Applicative (PgMonadT m)

MonadThrow m => MonadThrow (PgMonadT m)

MonadCatch m => MonadCatch (PgMonadT m)

MonadMask m => MonadMask (PgMonadT m)

MonadLogger m => MonadLogger (PgMonadT m)

MonadIO m => MonadIO (PgMonadT m)

MonadCont m => MonadCont (PgMonadT m)

TransactionSafe (PgMonadT m)

MonadBase IO m => HasPostgres (PgMonadT m)

type StT PgMonadT a = StT (ReaderT Connection) a

type StM (PgMonadT m) a = StM (ReaderT Connection m) a

runPgMonadT :: Connection -> PgMonadT m a -> m a

launchPG :: HasPostgres m => PgMonadT m a -> m a

If your monad have instance of HasPostgres you maybe dont need this function, unless your instance use withPGPool which acquires connection from pool for each query. If you want to run sequence of queries using same connection you need this function

Auxiliary types

newtype InetText

type to put and get from db inet and cidr typed postgresql fields. This should be in postgresql-simple in fact.

Constructors

InetText

Fields

unInetText :: Text

Instances

Eq InetText

Ord InetText

Read InetText

Show InetText

IsString InetText

Monoid InetText

FromField InetText

ToField InetText

Typeable * InetText

newtype FN

Dot-separated field name. Each element in nested list will be properly quoted and separated by dot. It also have instance of ToSqlBuilder and IsString so you can:

>>> let a = "hello" :: FN
>>> a
FN ["hello"]

>>> let b = "user.name" :: FN
>>> b
FN ["user","name"]

>>> let n = "u.name" :: FN
>>> runSqlBuilder c $ toSqlBuilder n
"\"u\".\"name\""

>>> ("user" <> "name") :: FN
FN ["user","name"]

>>> let a = "name" :: FN
>>> let b = "email" :: FN
>>> runSqlBuilder c [sqlExp|^{"u" <> a} = 'name', ^{"e" <> b} = 'email'|]
"\"u\".\"name\" = 'name', \"e\".\"email\" = 'email'"

Constructors

FN [Text]

Instances

Eq FN

Ord FN

Show FN

IsString FN

Generic FN

Monoid FN

ToSqlBuilder FN

Typeable * FN

type Rep FN

textFN :: Text -> FN

Single field to FN

>>> textFN "hello"
FN ["hello"]

>>> textFN "user.name"
FN ["user.name"]

Note that it does not split string to parts by point like instance of IsString does

newtype MarkedRow

Marked row is list of pairs of field name and some sql expression. Used to generate queries like:

name = name AND size = 10 AND length = 20

or

UPDATE tbl SET name = name, size = 10, lenght = 20

Constructors

MR

Fields

unMR :: [(FN, SqlBuilder)]

Instances

Generic MarkedRow

Monoid MarkedRow

ToMarkedRow MarkedRow

Typeable * MarkedRow

type Rep MarkedRow

mrToBuilder

Arguments

:: SqlBuilder

Builder to intercalate with

-> MarkedRow

-> SqlBuilder

Turns marked row to query intercalating it with other builder

>>> runSqlBuilder c $ mrToBuilder "AND" $ MR [("name", mkValue "petr"), ("email", mkValue "[e-mail]")]
" \"name\" = 'petr' AND \"email\" = '[e-mail]' "

class ToMarkedRow a where

Methods

toMarkedRow :: a -> MarkedRow

generate list of pairs (field name, field value)

Instances

ToMarkedRow MarkedRow