Control.Monad.Postgres.Base

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)
• (Alternative m) => Alternative (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)
• (MonadUnliftEffect m) => MonadUnliftEffect (PostgresT m)
• (MonadUnliftAff m) => MonadUnliftAff (PostgresT m)
• (MonadRec m) => MonadRec (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)
• (MonadBracket e f m, MonadAff m, MonadSession (SessionT m), MonadCursor (CursorT t (SessionT m)) t) => MonadPostgres (PostgresT m) (SessionT m) (CursorT ct (SessionT m)) ct

class MonadPostgres :: (Type -> Type) -> (Type -> Type) -> (Type -> Type) -> Type -> Constraintclass (MonadSession session, MonadCursor cursor ct) <= MonadPostgres m session cursor ct | m -> ct cursor session where

Typeclass generalizing PostgresT. Allows for dependency-injecting different implementations of the idea of a postgres connection.

• session - Session monad (for PostgresT this is SessionT)
• cursor - Cursor session monad (for PostgresT this is CursorT)
• ct - Open type parameter for cursor type. Don't pin this to a concrete type.

Members

• session :: session ~> m

  Run a session in m.

• transaction :: session ~> m

  Run a session in m, wrapped in a transaction.

  If any errors are raised, the transaction is rolled back and the error rethrown.

• cursorWith :: forall q. AsQuery q => (Array Raw -> RepT ct) -> String -> q -> cursor ~> m

  cursor, but using a custom deserialize function for the data yielded by the cursor

Instances

• (MonadBracket e f m, MonadAff m, MonadSession (SessionT m), MonadCursor (CursorT t (SessionT m)) t) => MonadPostgres (PostgresT m) (SessionT m) (CursorT ct (SessionT m)) ct

cursor :: forall @cursort t session cursor q a. MonadPostgres t session cursor cursort => AsQuery q => FromRow cursort => String -> q -> cursor a -> t a

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

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.

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.