Squeal.PostgreSQL.PQ

PQ is where Squeal statements come to actually get run by LibPQ. It contains a PQ indexed monad transformer to run Definitions and a MonadPQ constraint for running a Manipulation or Query.

Connection

newtype Connection (schema :: TablesType)

A Connection consists of a LibPQ Connection and a phantom TablesType

Constructors

Connection

Fields

• unConnection :: Connection

connectdb

Arguments

:: MonadBase IO io

=> ByteString

conninfo

-> io (Connection schema)

Makes a new connection to the database server.

This function opens a new database connection using the parameters taken from the string conninfo.

The passed string can be empty to use all default parameters, or it can contain one or more parameter settings separated by whitespace. Each parameter setting is in the form keyword = value. Spaces around the equal sign are optional. To write an empty value or a value containing spaces, surround it with single quotes, e.g., keyword = 'a value'. Single quotes and backslashes within the value must be escaped with a backslash, i.e., ' and .

To specify the schema you wish to connect with, use type application.

>>> :set -XDataKinds
>>> :set -XTypeOperators
>>> type Schema = '["tab" ::: '["col" ::: 'Required ('Null 'PGint2)]]
>>> :set -XTypeApplications
>>> :set -XOverloadedStrings
>>> conn <- connectdb @Schema "host=localhost port=5432 dbname=exampledb"

Note that, for now, squeal doesn't offer any protection from connecting with the wrong schema!

finish :: MonadBase IO io => Connection schema -> io ()

Closes the connection to the server.

withConnection :: forall schema0 schema1 io x. MonadBaseControl IO io => ByteString -> (Connection schema0 -> io (x, Connection schema1)) -> io x

Do connectdb and finish before and after a computation.

PQ

newtype PQ (schema0 :: TablesType) (schema1 :: TablesType) (m :: Type -> Type) (x :: Type)

We keep track of the schema via an Atkey indexed state monad transformer, PQ.

Constructors

PQ

Fields

• runPQ :: Connection schema0 -> m (x, Connection schema1)

Instances

MonadBase b m => MonadBase b (PQ schema schema m)

Methods

liftBase :: b α -> PQ schema schema m α

MonadBaseControl b m => MonadBaseControl b (PQ schema schema m)

Associated Types

type StM (PQ schema schema m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (PQ schema schema m) b -> b a) -> PQ schema schema m a

restoreM :: StM (PQ schema schema m) a -> PQ schema schema m a

MonadBase IO io => MonadPQ schema (PQ schema schema io)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> PQ schema schema io (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> PQ schema schema io (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> PQ schema schema io (Result ys)

runQuery :: Query schema [ColumnType] ys -> PQ schema schema io (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> PQ schema schema io (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> PQ schema schema io (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> PQ schema schema io ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> PQ schema schema io ()

liftPQ :: (Connection -> IO a) -> PQ schema schema io a

MonadTrans (PQ schema schema)

Methods

lift :: Monad m => m a -> PQ schema schema m a

Monad m => Monad (PQ schema schema m)

Methods

(>>=) :: PQ schema schema m a -> (a -> PQ schema schema m b) -> PQ schema schema m b

(>>) :: PQ schema schema m a -> PQ schema schema m b -> PQ schema schema m b

return :: a -> PQ schema schema m a

fail :: String -> PQ schema schema m a

Functor m => Functor (PQ schema0 schema1 m)

Methods

fmap :: (a -> b) -> PQ schema0 schema1 m a -> PQ schema0 schema1 m b

(<$) :: a -> PQ schema0 schema1 m b -> PQ schema0 schema1 m a

Monad m => Applicative (PQ schema schema m)

Methods

pure :: a -> PQ schema schema m a

(<*>) :: PQ schema schema m (a -> b) -> PQ schema schema m a -> PQ schema schema m b

liftA2 :: (a -> b -> c) -> PQ schema schema m a -> PQ schema schema m b -> PQ schema schema m c

(*>) :: PQ schema schema m a -> PQ schema schema m b -> PQ schema schema m b

(<*) :: PQ schema schema m a -> PQ schema schema m b -> PQ schema schema m a

type StM (PQ schema schema m) x

type StM (PQ schema schema m) x = StM m (x, Connection schema)

execPQ :: Functor m => PQ schema0 schema1 m x -> Connection schema0 -> m (Connection schema1)

Run a PQ and discard the result but keep the Connection.

pqAp :: Monad m => PQ schema0 schema1 m (x -> y) -> PQ schema1 schema2 m x -> PQ schema0 schema2 m y

indexed analog of <*>

pqBind :: Monad m => (x -> PQ schema1 schema2 m y) -> PQ schema0 schema1 m x -> PQ schema0 schema2 m y

indexed analog of =<<

pqThen :: Monad m => PQ schema1 schema2 m y -> PQ schema0 schema1 m x -> PQ schema0 schema2 m y

indexed analog of flipped >>

define :: MonadBase IO io => Definition schema0 schema1 -> PQ schema0 schema1 io (Result '[])

Run a Definition with exec, we expect that libpq obeys the law

define statement1 & thenDefine statement2 = define (statement1 >>> statement2)

thenDefine :: MonadBase IO io => Definition schema1 schema2 -> PQ schema0 schema1 io x -> PQ schema0 schema2 io (Result '[])

Chain together define actions.

MonadPQ

class Monad pq => MonadPQ schema pq | pq -> schema where

MonadPQ is an mtl style constraint, similar to MonadState, for using LibPQ to

• manipulateParams runs a Manipulation with params from a type with a ToParams constraint. It calls execParams and doesn't afraid of anything.
• manipulate is like manipulateParams for a parameter-free statement.
• runQueryParams is like manipulateParams for query statements.
• traversePrepared has the same type signature as a composition of traverse and manipulateParams but provides an optimization by preparing the statement with prepare and then traversing a Traversable container with execPrepared. The temporary prepared statement is then deallocated.
• forPrepared is a flipped traversePrepared
• traversePrepared_ is like traversePrepared but works on Foldable containers and returns unit.
• forPrepared_ is a flipped traversePrepared_.
• liftPQ lets you lift actions from LibPQ that require a connection into your monad.

To define an instance, you can minimally define only manipulateParams, traversePrepared, traversePrepared_ and liftPQ. Monad transformers get a default instance.

Methods

manipulateParams

Arguments

:: ToParams x params

=> Manipulation schema params ys

insertInto, update or deleteFrom

-> x

-> pq (Result ys)

manipulateParams

Arguments

:: (MonadTrans t, MonadPQ schema pq1, pq ~ t pq1)

=> ToParams x params

=> Manipulation schema params ys

insertInto, update or deleteFrom

-> x

-> pq (Result ys)

manipulate :: Manipulation schema '[] ys -> pq (Result ys)

runQueryParams

Arguments

:: ToParams x params

=> Query schema params ys

select and friends

-> x

-> pq (Result ys)

runQuery

Arguments

:: Query schema '[] ys

select and friends

-> pq (Result ys)

traversePrepared

Arguments

:: (ToParams x params, Traversable list)

=> Manipulation schema params ys

insertInto, update or deleteFrom

-> list x

-> pq (list (Result ys))

traversePrepared

Arguments

:: (MonadTrans t, MonadPQ schema pq1, pq ~ t pq1)

=> (ToParams x params, Traversable list)

=> Manipulation schema params ys

insertInto, update or deleteFrom

-> list x

-> pq (list (Result ys))

forPrepared

Arguments

:: (ToParams x params, Traversable list)

=> list x

-> Manipulation schema params ys

insertInto, update or deleteFrom

-> pq (list (Result ys))

traversePrepared_

Arguments

:: (ToParams x params, Foldable list)

=> Manipulation schema params '[]

insertInto, update or deleteFrom

-> list x

-> pq ()

traversePrepared_

Arguments

:: (MonadTrans t, MonadPQ schema pq1, pq ~ t pq1)

=> (ToParams x params, Foldable list)

=> Manipulation schema params '[]

insertInto, update or deleteFrom

-> list x

-> pq ()

forPrepared_

Arguments

:: (ToParams x params, Foldable list)

=> list x

-> Manipulation schema params '[]

insertInto, update or deleteFrom

-> pq ()

liftPQ :: (Connection -> IO a) -> pq a

liftPQ :: (MonadTrans t, MonadPQ schema pq1, pq ~ t pq1) => (Connection -> IO a) -> pq a

Instances

MonadPQ schema m => MonadPQ schema (ListT m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> ListT m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> ListT m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> ListT m (Result ys)

runQuery :: Query schema [ColumnType] ys -> ListT m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> ListT m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> ListT m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> ListT m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> ListT m ()

liftPQ :: (Connection -> IO a) -> ListT m a

MonadPQ schema m => MonadPQ schema (MaybeT m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> MaybeT m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> MaybeT m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> MaybeT m (Result ys)

runQuery :: Query schema [ColumnType] ys -> MaybeT m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> MaybeT m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> MaybeT m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> MaybeT m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> MaybeT m ()

liftPQ :: (Connection -> IO a) -> MaybeT m a

MonadPQ schema m => MonadPQ schema (ExceptT e m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> ExceptT e m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> ExceptT e m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> ExceptT e m (Result ys)

runQuery :: Query schema [ColumnType] ys -> ExceptT e m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> ExceptT e m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> ExceptT e m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> ExceptT e m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> ExceptT e m ()

liftPQ :: (Connection -> IO a) -> ExceptT e m a

(Monoid w, MonadPQ schema m) => MonadPQ schema (WriterT w m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> WriterT w m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> WriterT w m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> WriterT w m (Result ys)

runQuery :: Query schema [ColumnType] ys -> WriterT w m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> WriterT w m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> WriterT w m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> WriterT w m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> WriterT w m ()

liftPQ :: (Connection -> IO a) -> WriterT w m a

(Monoid w, MonadPQ schema m) => MonadPQ schema (WriterT w m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> WriterT w m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> WriterT w m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> WriterT w m (Result ys)

runQuery :: Query schema [ColumnType] ys -> WriterT w m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> WriterT w m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> WriterT w m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> WriterT w m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> WriterT w m ()

liftPQ :: (Connection -> IO a) -> WriterT w m a

MonadPQ schema m => MonadPQ schema (StateT s m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> StateT s m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> StateT s m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> StateT s m (Result ys)

runQuery :: Query schema [ColumnType] ys -> StateT s m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> StateT s m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> StateT s m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> StateT s m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> StateT s m ()

liftPQ :: (Connection -> IO a) -> StateT s m a

MonadPQ schema m => MonadPQ schema (StateT s m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> StateT s m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> StateT s m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> StateT s m (Result ys)

runQuery :: Query schema [ColumnType] ys -> StateT s m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> StateT s m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> StateT s m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> StateT s m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> StateT s m ()

liftPQ :: (Connection -> IO a) -> StateT s m a

MonadPQ schema m => MonadPQ schema (IdentityT * m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> IdentityT * m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> IdentityT * m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> IdentityT * m (Result ys)

runQuery :: Query schema [ColumnType] ys -> IdentityT * m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> IdentityT * m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> IdentityT * m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> IdentityT * m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> IdentityT * m ()

liftPQ :: (Connection -> IO a) -> IdentityT * m a

MonadPQ schema m => MonadPQ schema (ContT * r m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> ContT * r m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> ContT * r m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> ContT * r m (Result ys)

runQuery :: Query schema [ColumnType] ys -> ContT * r m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> ContT * r m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> ContT * r m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> ContT * r m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> ContT * r m ()

liftPQ :: (Connection -> IO a) -> ContT * r m a

MonadPQ schema m => MonadPQ schema (ReaderT * r m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> ReaderT * r m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> ReaderT * r m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> ReaderT * r m (Result ys)

runQuery :: Query schema [ColumnType] ys -> ReaderT * r m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> ReaderT * r m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> ReaderT * r m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> ReaderT * r m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> ReaderT * r m ()

liftPQ :: (Connection -> IO a) -> ReaderT * r m a

MonadBase IO io => MonadPQ schema (PQ schema schema io)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> PQ schema schema io (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> PQ schema schema io (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> PQ schema schema io (Result ys)

runQuery :: Query schema [ColumnType] ys -> PQ schema schema io (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> PQ schema schema io (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> PQ schema schema io (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> PQ schema schema io ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> PQ schema schema io ()

liftPQ :: (Connection -> IO a) -> PQ schema schema io a

(Monoid w, MonadPQ schema m) => MonadPQ schema (RWST r w s m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> RWST r w s m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> RWST r w s m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> RWST r w s m (Result ys)

runQuery :: Query schema [ColumnType] ys -> RWST r w s m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> RWST r w s m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> RWST r w s m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> RWST r w s m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> RWST r w s m ()

liftPQ :: (Connection -> IO a) -> RWST r w s m a

(Monoid w, MonadPQ schema m) => MonadPQ schema (RWST r w s m)

Methods

manipulateParams :: ToParams x params => Manipulation schema params ys -> x -> RWST r w s m (Result ys)

manipulate :: Manipulation schema [ColumnType] ys -> RWST r w s m (Result ys)

runQueryParams :: ToParams x params => Query schema params ys -> x -> RWST r w s m (Result ys)

runQuery :: Query schema [ColumnType] ys -> RWST r w s m (Result ys)

traversePrepared :: (ToParams x params, Traversable list) => Manipulation schema params ys -> list x -> RWST r w s m (list (Result ys))

forPrepared :: (ToParams x params, Traversable list) => list x -> Manipulation schema params ys -> RWST r w s m (list (Result ys))

traversePrepared_ :: (ToParams x params, Foldable list) => Manipulation schema params [(Symbol, ColumnType)] -> list x -> RWST r w s m ()

forPrepared_ :: (ToParams x params, Foldable list) => list x -> Manipulation schema params [(Symbol, ColumnType)] -> RWST r w s m ()

liftPQ :: (Connection -> IO a) -> RWST r w s m a

type PQRun schema = forall m x. Monad m => PQ schema schema m x -> m (x, Connection schema)

A snapshot of the state of a PQ computation.

pqliftWith :: Functor m => (PQRun schema -> m a) -> PQ schema schema m a

Helper function in defining MonadBaseControl instance for PQ.

Result

newtype Result (columns :: ColumnsType)

Encapsulates the result of a squeal command run by LibPQ. Results are parameterized by a ColumnsType describing the column names and their types.

Constructors

Result

Fields

• unResult :: Result

newtype RowNumber

Just newtypes around a CInt

Constructors

RowNumber

Fields

• unRowNumber :: Row

newtype ColumnNumber (n :: Nat) (cs :: [k]) (c :: k)

In addition to being newtypes around a CInt, a ColumnNumber is parameterized by a Natural number and acts as an index into a row.

Constructors

UnsafeColumnNumber

Fields

• getColumnNumber :: Column

class KnownNat n => HasColumnNumber n columns column | n columns -> column where

>>> getColumnNumber (columnNumber @5 @'[_,_,_,_,_,_])
Col 5

Methods

columnNumber :: ColumnNumber n columns column

Instances

(KnownNat n, HasColumnNumber k ((-) n 1) columns column) => HasColumnNumber k n ((:) k column' columns) column

Methods

columnNumber :: ColumnNumber n ((k ': column') columns) column column

HasColumnNumber k 0 ((:) k column1 columns) column1

Methods

columnNumber :: ColumnNumber 0 ((k ': column1) columns) column1 column

getValue

Arguments

:: (FromColumnValue colty y, MonadBase IO io)

=> RowNumber

row

-> ColumnNumber n columns colty

col

-> Result columns

result

-> io y

Get a single value corresponding to a given row and column number from a Result.

getRow

Arguments

:: (FromRow columns y, MonadBase IO io)

=> RowNumber

row

-> Result columns

result

-> io y

Get a row corresponding to a given row number from a Result.

getRows

Arguments

:: (FromRow columns y, MonadBase IO io)

=> Result columns

result

-> io [y]

Get all rows from a Result.

ntuples :: MonadBase IO io => Result columns -> io RowNumber

Returns the number of rows (tuples) in the query result.

nextRow

Arguments

:: (FromRow columns y, MonadBase IO io)

=> RowNumber

total number of rows

-> Result columns

result

-> RowNumber

row number

-> io (Maybe (RowNumber, y))

Intended to be used for unfolding in streaming libraries, nextRow takes a total number of rows (which can be found with ntuples) and a Result and given a row number if it's too large returns Nothing, otherwise returning the row along with the next row number.

firstRow

Arguments

:: (FromRow columns y, MonadBase IO io)

=> Result columns

result

-> io (Maybe y)

Get the first row if possible from a Result.

liftResult :: MonadBase IO io => (Result -> IO x) -> Result results -> io x

Lifts actions on results from LibPQ.