Safe Haskell	None
Language	Haskell2010

Opaleye.Manipulation

Description

Inserts, updates and deletes

Please note that Opaleye currently only supports INSERT or UPDATE with constant values, not the result of SELECTs. That is, you can generate SQL of the form

INSERT INTO thetable (John, 1);

but not

INSERT INTO thetable
   SELECT John,
   (SELECT num FROM thetable ORDER BY num DESC LIMIT 1) + 1;

Synopsis

data Delete haskells = forall fieldsW fieldsR. Delete {
- dTable :: Table fieldsW fieldsR
- dWhere :: fieldsR -> Field SqlBool
- dReturning :: Returning fieldsR haskells
}
data Update haskells = forall fieldsW fieldsR. Update {
- uTable :: Table fieldsW fieldsR
- uUpdateWith :: fieldsR -> fieldsW
- uWhere :: fieldsR -> Field SqlBool
- uReturning :: Returning fieldsR haskells
}
data Insert haskells = forall fieldsW fieldsR. Insert {
- iTable :: Table fieldsW fieldsR
- iRows :: [fieldsW]
- iReturning :: Returning fieldsR haskells
- iOnConflict :: Maybe OnConflict
}
runInsert_ :: Connection -> Insert haskells -> IO haskells
runUpdate_ :: Connection -> Update haskells -> IO haskells
runDelete_ :: Connection -> Delete haskells -> IO haskells
updateEasy :: Default Updater fieldsR fieldsW => (fieldsR -> fieldsR) -> fieldsR -> fieldsW
rCount :: Returning fieldsR Int64
rReturning :: Default FromFields fields haskells => (fieldsR -> fields) -> Returning fieldsR [haskells]
rReturningI :: Default (Inferrable FromFields) fields haskells => (fieldsR -> fields) -> Returning fieldsR [haskells]
rReturningExplicit :: FromFields fields haskells -> (fieldsR -> fields) -> Returning fieldsR [haskells]
runInsertManyOnConflictDoNothing :: Connection -> Table columns columns' -> [columns] -> IO Int64
runInsertManyReturningOnConflictDoNothing :: Default FromFields columnsReturned haskells => Connection -> Table columnsW columnsR -> [columnsW] -> (columnsR -> columnsReturned) -> IO [haskells]
runInsertMany :: Connection -> Table columns columns' -> [columns] -> IO Int64
runInsertManyReturning :: Default FromFields columnsReturned haskells => Connection -> Table columnsW columnsR -> [columnsW] -> (columnsR -> columnsReturned) -> IO [haskells]
runInsertReturningExplicit :: FromFields columnsReturned haskells -> Connection -> Table columnsW columnsR -> columnsW -> (columnsR -> columnsReturned) -> IO [haskells]
runInsertManyReturningExplicit :: FromFields columnsReturned haskells -> Connection -> Table columnsW columnsR -> [columnsW] -> (columnsR -> columnsReturned) -> IO [haskells]
runInsertManyReturningOnConflictDoNothingExplicit :: FromFields columnsReturned haskells -> Connection -> Table columnsW columnsR -> [columnsW] -> (columnsR -> columnsReturned) -> IO [haskells]
runUpdateEasy :: Default Updater columnsR columnsW => Connection -> Table columnsW columnsR -> (columnsR -> columnsR) -> (columnsR -> Column SqlBool) -> IO Int64
runUpdate :: Connection -> Table columnsW columnsR -> (columnsR -> columnsW) -> (columnsR -> Column SqlBool) -> IO Int64
runUpdateReturning :: Default FromFields columnsReturned haskells => Connection -> Table columnsW columnsR -> (columnsR -> columnsW) -> (columnsR -> Column SqlBool) -> (columnsR -> columnsReturned) -> IO [haskells]
runUpdateReturningExplicit :: FromFields columnsReturned haskells -> Connection -> Table columnsW columnsR -> (columnsR -> columnsW) -> (columnsR -> Column SqlBool) -> (columnsR -> columnsReturned) -> IO [haskells]
runDelete :: Connection -> Table a columnsR -> (columnsR -> Column SqlBool) -> IO Int64
data OnConflict = DoNothing

Documentation

data Delete haskells Source #

Constructors

forall fieldsW fieldsR. Delete
Fields dTable :: Table fieldsW fieldsR dWhere :: fieldsR -> Field SqlBool dReturning :: Returning fieldsR haskells

data Update haskells Source #

Constructors

forall fieldsW fieldsR. Update

Fields

uTable :: Table fieldsW fieldsR
uUpdateWith :: fieldsR -> fieldsW
Be careful: providing Nothing to a field created by optional updates the field to its default value. Many users have been confused by this because they assume it means that the field is to be left unchanged. For an easier time wrap your update function in updateEasy.
uWhere :: fieldsR -> Field SqlBool
uReturning :: Returning fieldsR haskells

data Insert haskells Source #

Constructors

forall fieldsW fieldsR. Insert
Fields iTable :: Table fieldsW fieldsR iRows :: [fieldsW] iReturning :: Returning fieldsR haskells iOnConflict :: Maybe OnConflict NB There is a clash of terminology between Haskell and Postgres. `iOnConflict` `=` `Nothing` means omit `ON CONFLICT` statement `iOnConflict` `=` `Just` `DoNothing` means `ON CONFLICT DO NOTHING`

runInsert_ Source #

Arguments

:: Connection
-> Insert haskells
-> IO haskells	Returns a type that depends on the `Returning` that you provided when creating the `Insert`.

Run the Insert. To create an Insert use the Insert constructor.

runUpdate_ Source #

Arguments

:: Connection
-> Update haskells
-> IO haskells	Returns a type that depends on the `Returning` that you provided when creating the `Update`.

Run the Update. To create an Update use the Update constructor.

runDelete_ Source #

Arguments

:: Connection
-> Delete haskells
-> IO haskells	Returns a type that depends on the `Returning` that you provided when creating the `Delete`.

Run the Delete. To create an Delete use the Delete constructor.

updateEasy Source #

Arguments

:: Default Updater fieldsR fieldsW
=> (fieldsR -> fieldsR)
-> fieldsR -> fieldsW

A convenient wrapper for writing your update function

uUpdateWith = updateEasy (\... -> ...)

rCount :: Returning fieldsR Int64 Source #

Return the number of rows inserted or updated

rReturning Source #

Arguments

:: Default FromFields fields haskells
=> (fieldsR -> fields)
-> Returning fieldsR [haskells]

Return a function of the inserted or updated rows

rReturning's use of the Default FromFields typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using rReturning.

rReturningI Source #

Arguments

:: Default (Inferrable FromFields) fields haskells
=> (fieldsR -> fields)
-> Returning fieldsR [haskells]

Like rReturning but with better inference properties. On the other hand the mapping from SQL fields to Haskell types is less flexible.

rReturningExplicit Source #

Arguments

:: FromFields fields haskells
-> (fieldsR -> fields)
-> Returning fieldsR [haskells]

Return a function of the inserted or updated rows. Explicit version. You probably just want to use rReturning instead.

runInsertManyOnConflictDoNothing Source #

Arguments

:: Connection
-> Table columns columns'	Table to insert into
-> [columns]	Rows to insert
-> IO Int64	Number of rows inserted

Deprecated: Use runInsert_. Will be removed in version 0.8.

Insert rows into a table with ON CONFLICT DO NOTHING

runInsertManyReturningOnConflictDoNothing Source #

Arguments

:: Default FromFields columnsReturned haskells
=> Connection
-> Table columnsW columnsR	Table to insert into
-> [columnsW]	Rows to insert
-> (columnsR -> columnsReturned)	Function `f` to apply to the inserted rows
-> IO [haskells]	Returned rows after `f` has been applied

Deprecated: Use runInsert_. Will be removed in version 0.8.

Insert rows into a table with ON CONFLICT DO NOTHING and return a function of the inserted rows

runInsertManyReturningOnConflictDoNothing's use of the Default typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using it.

runInsertMany Source #

Arguments

:: Connection
-> Table columns columns'	Table to insert into
-> [columns]	Rows to insert
-> IO Int64	Number of rows inserted