Control.Monad.Postgres

newtype PostgresT :: forall k. (k -> Type) -> k -> Typenewtype PostgresT m a

Monad handling pool resource acquisition & release

runPostgres
  {connectionString: "postgresql://postgres:postgres@localhost:5432"}
  $ session do
      exec_ "create table foo (bar int);"
      exec_ "insert into foo values (1);"
      res <- query "select * from foo"
      pure $ res == 1

Is equivalent to:

do
  pool <- liftEffect $ Pool.make {connectionString: "postgresql://postgres:postgres@localhost:5432"}
  finally (Pool.end pool) do
    client <- Pool.connect pool
    finally (liftEffect $ Pool.release pool client) do
      Client.exec_ "create table foo (bar int);" client
      Client.exec_ "insert into foo values (1);" client
      res <- Client.query "select * from foo" client
      pure $ res == 1

Constructors

• PostgresT (ReaderT Pool m a)

Instances

• Newtype (PostgresT m a) _
• (Functor m) => Functor (PostgresT m)
• (Apply m) => Apply (PostgresT m)
• (Applicative m) => Applicative (PostgresT m)
• (Plus m) => Plus (PostgresT m)
• (Alt m) => Alt (PostgresT m)
• (Bind m) => Bind (PostgresT m)
• (Monad m) => Monad (PostgresT m)
• (MonadEffect m) => MonadEffect (PostgresT m)
• (MonadAff m) => MonadAff (PostgresT m)
• MonadTrans PostgresT
• (MonadThrow e m) => MonadThrow e (PostgresT m)
• (MonadError e m) => MonadError e (PostgresT m)
• (MonadFork f m) => MonadFork f (PostgresT m)
• MFunctor PostgresT
• MMonad PostgresT
• (Apply m, Apply p, Parallel p m) => Parallel (PostgresT p) (PostgresT m)
• (Monad m, MonadKill e f m) => MonadKill e f (PostgresT m)
• (Monad m, MonadBracket e f (ReaderT Pool m), MonadBracket e f m) => MonadBracket e f (PostgresT m)
• (Monad m) => MonadAsk Pool (PostgresT m)
• (Monad m) => MonadReader Pool (PostgresT m)
• (MonadBracket e f m, MonadAff m) => MonadSession (PostgresT m)

withPool :: forall m a. PostgresT m a -> Pool -> m a

Execute a PostgresT using an existing connection pool.

This will not invoke Pool.end after executing.

transaction :: forall m a. MonadBracket Error Fiber m => MonadAff m => MonadSession (SessionT m) => SessionT m a -> PostgresT m a

Lifts a session to PostgresT, running the session in a transaction.

If the session throws an error, the transaction will be rolled back and the error rethrown.

session :: forall e f m a. MonadBracket e f m => MonadAff m => MonadSession (SessionT m) => SessionT m a -> PostgresT m a

Lifts a session to PostgresT, releasing the client to the pool after execution.

runPostgres :: forall m a missing trash r e f. MonadBracket e f m => MonadAff m => Union r missing (Config trash) => Record r -> PostgresT m a -> m a

Create a new connection pool from the provided config and execute the postgres monad, invoking Effect.Aff.Postgres.Pool.end afterwards.

newtype CursorT :: forall k. Type -> (k -> Type) -> k -> Typenewtype CursorT t m a

Constructors

• CursorT (ReaderT String m a)

Instances

• Newtype (CursorT t m a) _
• (Functor m) => Functor (CursorT t m)
• (Apply m) => Apply (CursorT t m)
• (Applicative m) => Applicative (CursorT t m)
• (Plus m) => Plus (CursorT t m)
• (Alt m) => Alt (CursorT t m)
• (Bind m) => Bind (CursorT t m)
• (Monad m) => Monad (CursorT t m)
• (MonadEffect m) => MonadEffect (CursorT t m)
• (MonadAff m) => MonadAff (CursorT t m)
• MonadTrans (CursorT t)
• (MonadThrow e m) => MonadThrow e (CursorT t m)
• (MonadError e m) => MonadError e (CursorT t m)
• (MonadFork f m) => MonadFork f (CursorT t m)
• (Monad m, MonadKill e f m) => MonadKill e f (CursorT t m)
• (Monad m, MonadBracket e f (ReaderT String m), MonadBracket e f m) => MonadBracket e f (CursorT t m)
• (Monad m) => MonadAsk String (CursorT t m)
• (Monad m) => MonadReader String (CursorT t m)
• (Apply m, Apply p, Parallel p m) => Parallel (CursorT t p) (CursorT t m)
• (FromRow t, MonadSession m) => MonadCursor (CursorT t m) t
• (MonadSession m) => MonadSession (CursorT t m)

class MonadCursor :: (Type -> Type) -> Type -> Constraintclass (MonadSession m, FromRow t) <= MonadCursor m t  where

A monad representing a handle to a server-side cursor

runPostgres {connectionString: "..."} do
  exec_ "create table foo (id int not null primary key);"
  exec_
    $ intercalate "\n "
      [ "insert into foo (id)"
      , "values"
      , intercalate ", "
          $ map (\n -> "(" <> show n <> ")")
          $ Array.range 1 100
      ]

  cursor @Int "foo_cursor" "select id from foo" do
    a <- fetchOne -- 1
    b <- fetchOne -- 2
    c <- fetchOne -- 3
    d <- fetch 10 -- 4..14
    e <- fetchAll -- 15..100
    pure unit

Members

• fetch :: Int -> m (Array t)

  Fetch a specified number of rows from the cursor

• fetchAll :: m (Array t)

  Fetch all remaining rows from the cursor

Instances

• (FromRow t, MonadSession m) => MonadCursor (CursorT t m) t

fetchOne :: forall m t. MonadCursor m t => m (Maybe t)

Fetch the next row from the cursor

cursor :: forall m @t a q. AsQuery q => MonadAff m => MonadBracket Error Fiber m => MonadSession (SessionT m) => String -> q -> CursorT t (SessionT m) a -> PostgresT m a

Create a server-side cursor for a query in a transaction, and execute a CursorT with a view to the new cursor.

type SessionT :: forall k. (k -> Type) -> k -> Typetype SessionT = ReaderT Client

Instances

• (MonadAff m) => MonadSession (SessionT m)

class MonadSession :: (Type -> Type) -> Constraintclass (MonadAff m) <= MonadSession m  where

A monad representing a connected session to a database

Members

• query :: forall q r. AsQuery q => FromRows r => q -> m r

  Executes a query and unmarshals the result into r

• exec :: forall q. AsQuery q => q -> m Int

  Executes a query and returns the number of rows affected

• exec_ :: forall q. AsQuery q => q -> m Unit

  Executes a query and discards the result

Instances

• (MonadAff m) => MonadSession (SessionT m)