Control.Monad.Postgres
- Package
- purescript-postgresql
- Repository
- cakekindel/purescript-postgresql
Re-exports from Control.Monad.Postgres.Base
#PostgresT Source
newtype PostgresT :: forall k. (k -> Type) -> k -> Type
newtype 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
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
#MonadPostgres Source
class MonadPostgres :: (Type -> Type) -> (Type -> Type) -> (Type -> Type) -> Type -> Constraint
class (Monad m, 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 (forPostgresT
this isSessionT
)cursor
- Cursor session monad (forPostgresT
this isCursorT
)ct
- Open type parameter for cursor type. Don't pin this to a concrete type.
Members
session :: session ~> 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
#runPostgres Source
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.
#cursor Source
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.
Re-exports from Control.Monad.Postgres.Cursor
#CursorT Source
newtype CursorT :: forall k. Type -> (k -> Type) -> k -> Type
newtype CursorT t m a
Constructors
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)
(Alternative m) => Alternative (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)
(MonadRec m) => MonadRec (CursorT t m)
(MonadUnliftEffect m) => MonadUnliftEffect (CursorT t m)
(MonadUnliftAff m) => MonadUnliftAff (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 (Tuple String (Array Raw -> RepT t)) (CursorT t m)
(Monad m) => MonadReader (Tuple String (Array Raw -> RepT t)) (CursorT t m)
(Apply m, Apply p, Parallel p m) => Parallel (CursorT t p) (CursorT t m)
(MonadSession m) => MonadCursor (CursorT t m) t
(MonadSession m) => MonadSession (CursorT t m)
#MonadCursor Source
class MonadCursor :: (Type -> Type) -> Type -> Constraint
class (MonadSession m) <= 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
move :: Move -> m Int
Change the cursor's position without fetching any data, returning the number of rows skipped.
Instances
(MonadSession m) => MonadCursor (CursorT t m) t
#fetchOne Source
fetchOne :: forall m t. MonadCursor m t => m (Maybe t)
Fetch the next row from the cursor
Re-exports from Control.Monad.Postgres.Session
#MonadSession Source
class MonadSession :: (Type -> Type) -> Constraint
class (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
streamIn :: String -> m (Writable ())
Execute a query with a
Writable
stream toSTDIN
Use with
COPY .. FROM
like so:w <- streamIn "COPY foo FROM STDIN WITH (FORMAT CSV, HEADER true)" liftEffect $ Stream.writeString "bar\n\"my bar column\"" UTF8 w
streamOut :: String -> m (Readable ())
Execute a query with a
Readable
stream fromSTDOUT
Use with
COPY .. TO
like so:r <- streamIn "COPY foo TO STDIN WITH (FORMAT CSV, HEADER true)" liftEffect $ Stream.readString r -- "bar\n\"my bar column\""
Instances
(MonadAff m) => MonadSession (SessionT m)
- Modules
- Control.
Monad. Postgres - Control.
Monad. Postgres. Base - Control.
Monad. Postgres. Cursor - Control.
Monad. Postgres. Session - Data.
Postgres - Data.
Postgres. Custom - Data.
Postgres. Custom. Enum - Data.
Postgres. Query - Data.
Postgres. Query. Builder - Data.
Postgres. Range - Data.
Postgres. Raw - Data.
Postgres. Result - Data.
Postgres. Unresult - Effect.
Aff. Postgres. Client - Effect.
Aff. Postgres. Pool - Effect.
Postgres. Client - Effect.
Postgres. Pool - Pipes.
Postgres
Run a session in
m
.