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)
import qualified Database.Relational.Query.Projection as Projection
import Database.Relational.Query.Projectable (expr)
import Database.Relational.Query.Sub (SubQuery, Qualified)
import Database.Relational.Query.Internal.Product (NodeAttr)
class (Functor m, Monad m) => MonadRestrict c m where
restrictContext :: Expr c (Maybe Bool)
-> m ()
class (Functor m, Monad m) => MonadQuery m where
setDuplication :: Duplication -> m ()
restrictJoin :: Expr Flat (Maybe Bool)
-> m ()
unsafeSubQuery :: NodeAttr
-> Qualified SubQuery
-> m (Projection Flat r)
class (Functor q, Monad q, MonadQuery 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
on :: MonadQuery m => Projection Flat (Maybe Bool) -> m ()
on = restrictJoin . expr
wheresE :: MonadRestrict Flat m => Expr Flat (Maybe Bool) -> m ()
wheresE = restrictContext
wheres :: MonadRestrict Flat m => Projection Flat (Maybe Bool) -> m ()
wheres = restrictContext . expr
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 = restrictContext
having :: MonadRestrict Aggregated m => Projection Aggregated (Maybe Bool) -> m ()
having = restrictContext . expr