Database.Relational.Monad.Class

This module defines query building interface classes.

Query interface classes

class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m where

Lift interface from base qualify monad.

Methods

liftQualify :: q a -> m a

Lift from qualify monad q into MonadQuery m. Qualify monad qualifies table form SubQuery.

Instances

(Functor q, Monad q) => MonadQualify q q

Defined in Database.Relational.Monad.Class

Methods

liftQualify :: q a -> q a

MonadQualify ConfigureQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

liftQualify :: ConfigureQuery a -> QueryUnique a

MonadQualify q m => MonadQualify q (QueryJoin m)

Defined in Database.Relational.Monad.Trans.Join

Methods

liftQualify :: q a -> QueryJoin m a

MonadQualify q m => MonadQualify q (AggregatingSetT m)

Aggregated MonadQualify.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

liftQualify :: q a -> AggregatingSetT m a

MonadQualify q m => MonadQualify q (Restrictings c m)

Restricted MonadQualify instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

liftQualify :: q a -> Restrictings c m a

MonadQualify q m => MonadQualify q (Orderings c m)

MonadQualify with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

liftQualify :: q a -> Orderings c m a

MonadQualify q m => MonadQualify q (Assignings r m)

MonadQualify with assigning.

Defined in Database.Relational.Monad.Trans.Assigning

Methods

liftQualify :: q a -> Assignings r m a

class (Functor m, Monad m) => MonadRestrict c m where

Restrict context interface

Methods

restrict

Arguments

:: Predicate c

Record which represent restriction

-> m ()

Restricted query context

Add restriction to this context.

Instances

MonadRestrict c m => MonadRestrict c (AggregatingSetT m)

Aggregated MonadRestrict.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

restrict :: Predicate c -> AggregatingSetT m ()

(Monad q, Functor q) => MonadRestrict c (Restrictings c q)

MonadRestrict instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

restrict :: Predicate c -> Restrictings c q ()

MonadRestrict rc m => MonadRestrict rc (Orderings c m)

MonadRestrict with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

restrict :: Predicate rc -> Orderings c m ()

MonadRestrict c m => MonadRestrict c (Assignings r m)

MonadRestrict with assigning.

Defined in Database.Relational.Monad.Trans.Assigning

Methods

restrict :: Predicate c -> Assignings r m ()

MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q)

Restricted MonadRestrict instance.

Defined in Database.Relational.Monad.Aggregate

Methods

restrict :: Predicate Flat -> Restrictings Aggregated q ()

class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery m where

Query building interface.

Methods

setDuplication :: Duplication -> m ()

Specify duplication.

restrictJoin

Arguments

:: Predicate Flat

Record which represent restriction

-> m ()

Restricted query context

Add restriction to last join.

query' :: Relation p r -> m (PlaceHolders p, Record Flat r)

Join sub-query with place-holder parameter p. query result is not Maybe.

queryMaybe' :: Relation p r -> m (PlaceHolders p, Record Flat (Maybe r))

Join sub-query with place-holder parameter p. Query result is Maybe.

Instances

MonadQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

setDuplication :: Duplication -> QueryUnique ()

restrictJoin :: Predicate Flat -> QueryUnique ()

query' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat (Maybe r))

MonadQuery (QueryJoin ConfigureQuery)

Joinable query instance.

Defined in Database.Relational.Monad.Trans.Join

Methods

setDuplication :: Duplication -> QueryJoin ConfigureQuery ()

restrictJoin :: Predicate Flat -> QueryJoin ConfigureQuery ()

query' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat (Maybe r))

MonadQuery m => MonadQuery (AggregatingSetT m)

Aggregated MonadQuery.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

setDuplication :: Duplication -> AggregatingSetT m ()

restrictJoin :: Predicate Flat -> AggregatingSetT m ()

query' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat (Maybe r))

MonadQuery q => MonadQuery (Restrictings c q)

Restricted MonadQuery instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

setDuplication :: Duplication -> Restrictings c q ()

restrictJoin :: Predicate Flat -> Restrictings c q ()

query' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat (Maybe r))

MonadQuery m => MonadQuery (Orderings c m)

MonadQuery with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

setDuplication :: Duplication -> Orderings c m ()

restrictJoin :: Predicate Flat -> Orderings c m ()

query' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat (Maybe r))

class MonadQuery m => MonadAggregate m where

Aggregated query building interface extends MonadQuery.

Methods

groupBy

Arguments

:: Record Flat r

Record to add into group by

-> m (Record Aggregated r)

Result context and aggregated record | Add GROUP BY term into context and get aggregated record. Non-traditional group-by version.

Add GROUP BY term into context and get aggregated record.

groupBy'

Arguments

:: AggregateKey (Record Aggregated r)

Key to aggretate for non-traditional group-by interface

-> m (Record Aggregated r)

Result context and aggregated record

Instances

MonadQuery m => MonadAggregate (AggregatingSetT m)

Aggregated query instance.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

groupBy :: Record Flat r -> AggregatingSetT m (Record Aggregated r)

groupBy' :: AggregateKey (Record Aggregated r) -> AggregatingSetT m (Record Aggregated r)

MonadAggregate m => MonadAggregate (Restrictings c m)

Resticted MonadAggregate instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

groupBy :: Record Flat r -> Restrictings c m (Record Aggregated r)

groupBy' :: AggregateKey (Record Aggregated r) -> Restrictings c m (Record Aggregated r)

MonadAggregate m => MonadAggregate (Orderings c m)

MonadAggregate with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

groupBy :: Record Flat r -> Orderings c m (Record Aggregated r)

groupBy' :: AggregateKey (Record Aggregated r) -> Orderings c m (Record Aggregated r)

class Monad m => MonadPartition c m where

Window specification building interface.

Methods

partitionBy :: Record c r -> m ()

Add PARTITION BY term into context.

Instances

MonadPartition c m => MonadPartition c (Orderings c m)

MonadPartition with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

partitionBy :: Record c r -> Orderings c m ()

Monad m => MonadPartition c (PartitioningSetT c m)

Partition clause instance

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

partitionBy :: Record c r -> PartitioningSetT c m ()

all' :: MonadQuery m => m ()

Specify ALL attribute to query context.

distinct :: MonadQuery m => m ()

Specify DISTINCT attribute to query context.

on :: MonadQuery m => Predicate Flat -> m ()

Add restriction to last join. Record type version.

wheres :: MonadRestrict Flat m => Predicate Flat -> m ()

Add restriction to this not aggregated query.

having :: MonadRestrict Aggregated m => Predicate Aggregated -> m ()

Add restriction to this aggregated query. Aggregated Record type version.