Safe Haskell | Safe-Infered |
---|
This is an internal module, anything exported by this module may change without a major version bump. Please use only Database.Esqueleto if possible.
- data SqlQuery a
- data SqlExpr a
- select :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m [r]
- selectSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)
- selectDistinct :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m [r]
- selectDistinctSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)
- delete :: (MonadLogger m, MonadResourceBase m) => SqlQuery () -> SqlPersist m ()
- update :: (MonadLogger m, MonadResourceBase m, PersistEntity val, PersistEntityBackend val ~ SqlPersist) => (SqlExpr (Entity val) -> SqlQuery ()) -> SqlPersist m ()
- rawSelectSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => Mode -> SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)
- runSource :: MonadResourceBase m => Source (ResourceT (SqlPersist m)) r -> SqlPersist m [r]
- rawExecute :: (MonadLogger m, MonadResourceBase m) => Mode -> SqlQuery () -> SqlPersist m ()
- toRawSql :: SqlSelect a r => Mode -> Escape -> SqlQuery a -> (Builder, [PersistValue])
- data Mode
- = SELECT
- | SELECT_DISTINCT
- | DELETE
- | UPDATE
- type Escape = DBName -> Builder
- class SqlSelect a r | a -> r, r -> a
The pretty face
SQL backend for esqueleto
using SqlPersist
.
An expression on the SQL backend.
Esqueleto SqlQuery SqlExpr SqlPersist | |
PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a)) | |
PersistEntity a => SqlSelect (SqlExpr (Entity a)) (Entity a) | |
PersistField a => SqlSelect (SqlExpr (Value a)) (Value a) | You may return any single value (i.e. a single column) from
a |
select :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m [r]Source
Execute an esqueleto
SELECT
query inside persistent
's
SqlPersist
monad and return a list of rows.
We've seen that from
has some magic about which kinds of
things you may bring into scope. This select
function also
has some magic for which kinds of things you may bring back to
Haskell-land by using SqlQuery
's return
:
- You may return a
SqlExpr (
for an entityEntity
v)v
(i.e., like the*
in SQL), which is then returned to Haskell-land as justEntity v
. - You may return a
SqlExpr (Maybe (Entity v))
for an entityv
that may beNULL
, which is then returned to Haskell-land asMaybe (Entity v)
. Used forOUTER JOIN
s. - You may return a
SqlExpr (
for a valueValue
t)t
(i.e., a single column), wheret
is any instance ofPersistField
, which is then returned to Haskell-land asValue t
. You may useValue
to return projections of anEntity
(see(
and^.
)(
) or to return any other value calculated on the query (e.g.,?.
)countRows
orsub_select
).
The SqlSelect a r
class has functional dependencies that
allow type information to flow both from a
to r
and
vice-versa. This means that you'll almost never have to give
any type signatures for esqueleto
queries. For example, the
query select $ from $ \p -> return p
alone is ambiguous, but
in the context of
do ps <- select $ from $ \p -> return p liftIO $ mapM_ (putStrLn . personName . entityVal) ps
we are able to infer from that single personName . entityVal
function composition that the p
inside the query is of type
SqlExpr (Entity Person)
.
selectSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)Source
Execute an esqueleto
SELECT
query inside persistent
's
SqlPersist
monad and return a Source
of rows.
selectDistinct :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m [r]Source
Execute an esqueleto
SELECT DISTINCT
query inside
persistent
's SqlPersist
monad and return a list of rows.
selectDistinctSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)Source
Execute an esqueleto
SELECT DISTINCT
query inside
persistent
's SqlPersist
monad and return a Source
of
rows.
delete :: (MonadLogger m, MonadResourceBase m) => SqlQuery () -> SqlPersist m ()Source
Execute an esqueleto
DELETE
query inside persistent
's
SqlPersist
monad. Note that currently there are no type
checks for statements that should not appear on a DELETE
query.
Example of usage:
delete $ from $ \appointment -> where_ (appointment ^. AppointmentDate <. val now)
Unlike select
, there is a useful way of using delete
that
will lead to type ambiguities. If you want to delete all rows
(i.e., no where_
clause), you'll have to use a type signature:
delete $ from $ \(appointment :: SqlExpr (Entity Appointment)) -> return ()
update :: (MonadLogger m, MonadResourceBase m, PersistEntity val, PersistEntityBackend val ~ SqlPersist) => (SqlExpr (Entity val) -> SqlQuery ()) -> SqlPersist m ()Source
Execute an esqueleto
UPDATE
query inside persistent
's
SqlPersist
monad. Note that currently there are no type
checks for statements that should not appear on a UPDATE
query.
Example of usage:
update $ p -> do set p [ PersonAge =. just (val thisYear) -. p ^. PersonBorn ] where_ $ isNull (p ^. PersonAge)
The guts
rawSelectSource :: (SqlSelect a r, MonadLogger m, MonadResourceBase m) => Mode -> SqlQuery a -> SqlPersist m (Source (ResourceT (SqlPersist m)) r)Source
(Internal) Execute an esqueleto
SELECT
SqlQuery
inside
persistent
's SqlPersist
monad.
runSource :: MonadResourceBase m => Source (ResourceT (SqlPersist m)) r -> SqlPersist m [r]Source
(Internal) Run a Source
of rows.
rawExecute :: (MonadLogger m, MonadResourceBase m) => Mode -> SqlQuery () -> SqlPersist m ()Source
(Internal) Execute an esqueleto
statement inside
persistent
's SqlPersist
monad.
toRawSql :: SqlSelect a r => Mode -> Escape -> SqlQuery a -> (Builder, [PersistValue])Source
(Internal) Pretty prints a SqlQuery
into a SQL query.
Note: if you're curious about the SQL query being generated by
esqueleto
, instead of manually using this function (which is
possible but tedious), you may just turn on query logging of
persistent
.
(Internal) Mode of query being converted by toRawSql
.
class SqlSelect a r | a -> r, r -> aSource
(Internal) Class for mapping results coming from SqlQuery
into actual results.
This looks very similar to RawSql
, and it is! However,
there are some crucial differences and ultimately they're
different classes.
SqlSelect () () | |
PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a)) | |
PersistEntity a => SqlSelect (SqlExpr (Entity a)) (Entity a) | |
PersistField a => SqlSelect (SqlExpr (Value a)) (Value a) | You may return any single value (i.e. a single column) from
a |
(SqlSelect a ra, SqlSelect b rb) => SqlSelect (a, b) (ra, rb) | You may return tuples (up to 8-tuples) and tuples of tuples
from a |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc) => SqlSelect (a, b, c) (ra, rb, rc) | |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc, SqlSelect d rd) => SqlSelect (a, b, c, d) (ra, rb, rc, rd) | |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc, SqlSelect d rd, SqlSelect e re) => SqlSelect (a, b, c, d, e) (ra, rb, rc, rd, re) | |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc, SqlSelect d rd, SqlSelect e re, SqlSelect f rf) => SqlSelect (a, b, c, d, e, f) (ra, rb, rc, rd, re, rf) | |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc, SqlSelect d rd, SqlSelect e re, SqlSelect f rf, SqlSelect g rg) => SqlSelect (a, b, c, d, e, f, g) (ra, rb, rc, rd, re, rf, rg) | |
(SqlSelect a ra, SqlSelect b rb, SqlSelect c rc, SqlSelect d rd, SqlSelect e re, SqlSelect f rf, SqlSelect g rg, SqlSelect h rh) => SqlSelect (a, b, c, d, e, f, g, h) (ra, rb, rc, rd, re, rf, rg, rh) |