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

Minimal complete definition

withPGConnection

Methods

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

Instances

HasPostgres m => HasPostgres (MaybeT m)

Methods

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

MonadBase IO m => HasPostgres (PgMonadT m)

Methods

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

HasPostgres m => HasPostgres (IdentityT * m)

Methods

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

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

Methods

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

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

Methods

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

HasPostgres m => HasPostgres (StateT s m)

Methods

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

HasPostgres m => HasPostgres (StateT s m)

Methods

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

HasPostgres m => HasPostgres (EitherT e m)

Methods

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

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

Methods

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

HasPostgres m => HasPostgres (ExceptT e m)

Methods

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

HasPostgres m => HasPostgres (ReaderT * r m)

Methods

withPGConnection :: (Connection -> ReaderT * r m a) -> ReaderT * r m a

HasPostgres m => HasPostgres (ContT * r m)

Methods

withPGConnection :: (Connection -> ContT * r m a) -> ContT * r m a

type MonadPostgres m = (HasPostgres m, MonadLogger 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 (MaybeT m)

TransactionSafe (PgMonadT m)

TransactionSafe m => TransactionSafe (IdentityT * 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 (EitherT e m)

TransactionSafe m => TransactionSafe (ExceptT e m)

TransactionSafe m => TransactionSafe (ReaderT * r m)

TransactionSafe m => TransactionSafe (ContT * r 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

Methods

lift :: Monad m => m a -> PgMonadT m a

MonadTransControl PgMonadT

Associated Types

type StT (PgMonadT :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run PgMonadT -> m a) -> PgMonadT m a

restoreT :: Monad m => m (StT PgMonadT a) -> PgMonadT m a

MonadBaseControl b m => MonadBaseControl b (PgMonadT m)

Associated Types

type StM (PgMonadT m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (PgMonadT m) b -> b a) -> PgMonadT m a

restoreM :: StM (PgMonadT m) a -> PgMonadT m a

MonadBase b m => MonadBase b (PgMonadT m)

Methods

liftBase :: b α -> PgMonadT m α

MonadError e m => MonadError e (PgMonadT m)

Methods

throwError :: e -> PgMonadT m a

catchError :: PgMonadT m a -> (e -> PgMonadT m a) -> PgMonadT m a

MonadReader r m => MonadReader r (PgMonadT m)

Methods

ask :: PgMonadT m r

local :: (r -> r) -> PgMonadT m a -> PgMonadT m a

reader :: (r -> a) -> PgMonadT m a

MonadState s m => MonadState s (PgMonadT m)

Methods

get :: PgMonadT m s

put :: s -> PgMonadT m ()

state :: (s -> (a, s)) -> PgMonadT m a

MonadWriter w m => MonadWriter w (PgMonadT m)

Methods

writer :: (a, w) -> PgMonadT m a

tell :: w -> PgMonadT m ()

listen :: PgMonadT m a -> PgMonadT m (a, w)

pass :: PgMonadT m (a, w -> w) -> PgMonadT m a

Monad m => Monad (PgMonadT m)

Methods

(>>=) :: PgMonadT m a -> (a -> PgMonadT m b) -> PgMonadT m b

(>>) :: PgMonadT m a -> PgMonadT m b -> PgMonadT m b

return :: a -> PgMonadT m a

fail :: String -> PgMonadT m a

Functor m => Functor (PgMonadT m)

Methods

fmap :: (a -> b) -> PgMonadT m a -> PgMonadT m b

(<$) :: a -> PgMonadT m b -> PgMonadT m a

MonadFix m => MonadFix (PgMonadT m)

Methods

mfix :: (a -> PgMonadT m a) -> PgMonadT m a

Applicative m => Applicative (PgMonadT m)

Methods

pure :: a -> PgMonadT m a

(<*>) :: PgMonadT m (a -> b) -> PgMonadT m a -> PgMonadT m b

(*>) :: PgMonadT m a -> PgMonadT m b -> PgMonadT m b

(<*) :: PgMonadT m a -> PgMonadT m b -> PgMonadT m a

MonadPlus m => MonadPlus (PgMonadT m)

Methods

mzero :: PgMonadT m a

mplus :: PgMonadT m a -> PgMonadT m a -> PgMonadT m a

MonadIO m => MonadIO (PgMonadT m)

Methods

liftIO :: IO a -> PgMonadT m a

Alternative m => Alternative (PgMonadT m)

Methods

empty :: PgMonadT m a

(<|>) :: PgMonadT m a -> PgMonadT m a -> PgMonadT m a

some :: PgMonadT m a -> PgMonadT m [a]

many :: PgMonadT m a -> PgMonadT m [a]

MonadThrow m => MonadThrow (PgMonadT m)

Methods

throwM :: Exception e => e -> PgMonadT m a

MonadCatch m => MonadCatch (PgMonadT m)

Methods

catch :: Exception e => PgMonadT m a -> (e -> PgMonadT m a) -> PgMonadT m a

MonadMask m => MonadMask (PgMonadT m)

Methods

mask :: ((forall a. PgMonadT m a -> PgMonadT m a) -> PgMonadT m b) -> PgMonadT m b

uninterruptibleMask :: ((forall a. PgMonadT m a -> PgMonadT m a) -> PgMonadT m b) -> PgMonadT m b

MonadHReader m => MonadHReader (PgMonadT m)

Associated Types

type MHRElements (PgMonadT m :: * -> *) :: [*]

Methods

askHSet :: PgMonadT m (HSet (MHRElements (PgMonadT m)))

hlocal :: (HSet (MHRElements (PgMonadT m)) -> HSet (MHRElements (PgMonadT m))) -> PgMonadT m a -> PgMonadT m a

MonadLogger m => MonadLogger (PgMonadT m)

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> PgMonadT m ()

MonadCont m => MonadCont (PgMonadT m)

Methods

callCC :: ((a -> PgMonadT m b) -> PgMonadT m a) -> PgMonadT m a

TransactionSafe (PgMonadT m)

MonadBase IO m => HasPostgres (PgMonadT m)

Methods

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

type StT PgMonadT a

type StT PgMonadT a = StT (ReaderT * Connection) a

type MHRElements (PgMonadT m)

type MHRElements (PgMonadT m) = MHRElements m

type StM (PgMonadT m) 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

data Qp

Special constructor to perform old-style query interpolation

Constructors

ToRow row => Qp Query row

Instances

ToSqlBuilder Qp

Methods

toSqlBuilder :: Qp -> SqlBuilder

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

Methods

(==) :: InetText -> InetText -> Bool

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

Ord InetText

Methods

compare :: InetText -> InetText -> Ordering

(<) :: InetText -> InetText -> Bool

(<=) :: InetText -> InetText -> Bool

(>) :: InetText -> InetText -> Bool

(>=) :: InetText -> InetText -> Bool

max :: InetText -> InetText -> InetText

min :: InetText -> InetText -> InetText

Read InetText

Methods

readsPrec :: Int -> ReadS InetText

readList :: ReadS [InetText]

readPrec :: ReadPrec InetText

readListPrec :: ReadPrec [InetText]

Show InetText

Methods

showsPrec :: Int -> InetText -> ShowS

show :: InetText -> String

showList :: [InetText] -> ShowS

IsString InetText

Methods

fromString :: String -> InetText

Monoid InetText

Methods

mempty :: InetText

mappend :: InetText -> InetText -> InetText

mconcat :: [InetText] -> InetText

ToField InetText

Methods

toField :: InetText -> Action

FromField InetText

Methods

fromField :: FieldParser 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

Methods

(==) :: FN -> FN -> Bool

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

Ord FN

Methods

compare :: FN -> FN -> Ordering

(<) :: FN -> FN -> Bool

(<=) :: FN -> FN -> Bool

(>) :: FN -> FN -> Bool

(>=) :: FN -> FN -> Bool

max :: FN -> FN -> FN

min :: FN -> FN -> FN

Show FN

Methods

showsPrec :: Int -> FN -> ShowS

show :: FN -> String

showList :: [FN] -> ShowS

IsString FN

Methods

fromString :: String -> FN

Generic FN

Associated Types

type Rep FN :: * -> *

Methods

from :: FN -> Rep FN x

to :: Rep FN x -> FN

Monoid FN

Methods

mempty :: FN

mappend :: FN -> FN -> FN

mconcat :: [FN] -> FN

Lift FN

Methods

lift :: FN -> Q Exp

ToSqlBuilder FN

Methods

toSqlBuilder :: FN -> SqlBuilder

type Rep FN

type Rep FN = D1 (MetaData "FN" "Database.PostgreSQL.Query.Types" "postgresql-query-3.1.0-JIgOGuFIL8OH5talOVcy5c" True) (C1 (MetaCons "FN" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Text])))

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

Associated Types

type Rep MarkedRow :: * -> *

Methods

from :: MarkedRow -> Rep MarkedRow x

to :: Rep MarkedRow x -> MarkedRow

Monoid MarkedRow

Methods

mempty :: MarkedRow

mappend :: MarkedRow -> MarkedRow -> MarkedRow

mconcat :: [MarkedRow] -> MarkedRow

ToMarkedRow MarkedRow

Methods

toMarkedRow :: MarkedRow -> MarkedRow

type Rep MarkedRow

type Rep MarkedRow = D1 (MetaData "MarkedRow" "Database.PostgreSQL.Query.Types" "postgresql-query-3.1.0-JIgOGuFIL8OH5talOVcy5c" True) (C1 (MetaCons "MR" PrefixI True) (S1 (MetaSel (Just Symbol "unMR") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(FN, SqlBuilder)])))

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

Minimal complete definition

toMarkedRow

Methods

toMarkedRow :: a -> MarkedRow

generate list of pairs (field name, field value)

Instances

ToMarkedRow MarkedRow

Methods

toMarkedRow :: MarkedRow -> MarkedRow