module Database.Relational.Query.Monad.Class
(
MonadQualify (..), MonadRestrict (..),
MonadQuery (..), MonadAggregate (..), MonadPartition (..),
all', distinct,
onE, on, wheresE, wheres,
havingE, having,
) where
import Database.Relational.Query.Context (Flat, Aggregated)
import Database.Relational.Query.Expr (Expr)
import Database.Relational.Query.Component (Duplication (..), AggregateKey)
import Database.Relational.Query.Projection (Projection, predicateProjectionFromExpr)
import Database.Relational.Query.Projectable (PlaceHolders)
import Database.Relational.Query.Monad.BaseType (ConfigureQuery, Relation)
class (Functor m, Monad m) => MonadRestrict c m where
restrict :: Projection c (Maybe Bool)
-> m ()
class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery m where
setDuplication :: Duplication -> m ()
restrictJoin :: Projection Flat (Maybe Bool)
-> m ()
query' :: Relation p r
-> m (PlaceHolders p, Projection Flat r)
queryMaybe' :: Relation p r
-> m (PlaceHolders p, Projection Flat (Maybe r))
class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m where
liftQualify :: q a -> m a
instance (Functor q, Monad q) => MonadQualify q q where
liftQualify = id
class MonadQuery m => MonadAggregate m where
groupBy :: Projection Flat r
-> m (Projection Aggregated r)
groupBy' :: AggregateKey (Projection Aggregated r)
-> m (Projection Aggregated r)
class Monad m => MonadPartition c m where
partitionBy :: Projection c r -> m ()
all' :: MonadQuery m => m ()
all' = setDuplication All
distinct :: MonadQuery m => m ()
distinct = setDuplication Distinct
onE :: MonadQuery m => Expr Flat (Maybe Bool) -> m ()
onE = restrictJoin . predicateProjectionFromExpr
on :: MonadQuery m => Projection Flat (Maybe Bool) -> m ()
on = restrictJoin
wheresE :: MonadRestrict Flat m => Expr Flat (Maybe Bool) -> m ()
wheresE = restrict . predicateProjectionFromExpr
wheres :: MonadRestrict Flat m => Projection Flat (Maybe Bool) -> m ()
wheres = restrict
havingE :: MonadRestrict Aggregated m => Expr Aggregated (Maybe Bool) -> m ()
havingE = restrict . predicateProjectionFromExpr
having :: MonadRestrict Aggregated m => Projection Aggregated (Maybe Bool) -> m ()
having = restrict