module Database.Relational.Query.Monad.Class (
MonadQualify (..), MonadQualifyUnique(..), MonadRestrict (..),
MonadQuery (..), MonadAggregate (..), MonadPartition (..),
all', distinct,
onE, on, wheresE, wheres,
groupBy,
havingE, having
) where
import Database.Relational.Query.Context (Flat, Aggregated)
import Database.Relational.Query.Expr (Expr)
import Database.Relational.Query.Component
(Duplication (..), AggregateElem, AggregateColumnRef, aggregateColumnRef)
import Database.Relational.Query.Projection (Projection, predicateProjectionFromExpr)
import qualified Database.Relational.Query.Projection as Projection
import Database.Relational.Query.Sub (SubQuery, Qualified)
import Database.Relational.Query.Internal.Product (NodeAttr)
class (Functor m, Monad m) => MonadRestrict c m where
restrict :: Projection c (Maybe Bool)
-> m ()
class (Functor m, Monad m) => MonadQuery m where
setDuplication :: Duplication -> m ()
restrictJoin :: Projection Flat (Maybe Bool)
-> m ()
unsafeSubQuery :: NodeAttr
-> Qualified SubQuery
-> m (Projection Flat r)
class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m where
liftQualify :: q a -> m a
class (Functor q, Monad q, MonadQuery m) => MonadQualifyUnique q m where
liftQualifyUnique :: q a -> m a
class MonadQuery m => MonadAggregate m where
unsafeAddAggregateElement :: AggregateElem
-> m ()
class Monad m => MonadPartition m where
unsafeAddPartitionKey :: AggregateColumnRef
-> 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
groupBy :: MonadAggregate m
=> Projection Flat r
-> m (Projection Aggregated r)
groupBy p = do
mapM_ unsafeAddAggregateElement [ aggregateColumnRef col | col <- Projection.columns p]
return $ Projection.unsafeToAggregated p
havingE :: MonadRestrict Aggregated m => Expr Aggregated (Maybe Bool) -> m ()
havingE = restrict . predicateProjectionFromExpr
having :: MonadRestrict Aggregated m => Projection Aggregated (Maybe Bool) -> m ()
having = restrict