{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Database.Relational.Arrow (
module Database.Relational,
all', distinct,
query, queryMaybe, query', queryMaybe',
queryList, queryList', queryExists, queryExists', queryListU, queryListU',
queryScalar, queryScalar', queryScalarU, queryScalarU',
uniqueQuery', uniqueQueryMaybe',
on, wheres, having, groupBy, placeholder,
relation, relation', aggregateRelation, aggregateRelation',
uniqueRelation',
groupBy', key, key', set, bkey, rollup, cube, groupingSets,
orderBy', orderBy, asc, desc,
partitionBy, over,
assign,
update', update, updateNoPH,
updateAllColumn', updateAllColumn, updateAllColumnNoPH,
insertValue', insertValue, insertValueNoPH,
delete', delete, deleteNoPH,
QueryA,
QuerySimple, QueryAggregate, QueryUnique,
AggregatingSet, AggregatingSetList, AggregatingPowerSet,
Orderings, Window, Assignings,
AssignStatement, Register, RestrictedStatement,
derivedUpdate', derivedUpdate,
derivedInsertValue', derivedInsertValue,
derivedDelete', derivedDelete,
) where
import Control.Category (Category)
import Control.Arrow (Arrow, Kleisli (..))
import Database.Record
import Database.Relational hiding
(all', distinct,
query, queryMaybe, query', queryMaybe',
queryList, queryList', queryScalar, queryScalar',
uniqueQuery', uniqueQueryMaybe',
on, wheres, having, groupBy, placeholder,
relation, relation', aggregateRelation, aggregateRelation', uniqueRelation',
groupBy', key, key', set, bkey, rollup, cube, groupingSets,
orderBy', orderBy, asc, desc, partitionBy, over,
update', update, updateNoPH, derivedUpdate', derivedUpdate,
updateAllColumn', updateAllColumn, updateAllColumnNoPH,
insertValue', insertValue, insertValueNoPH, derivedInsertValue', derivedInsertValue,
delete', delete, deleteNoPH, derivedDelete', derivedDelete,
QuerySimple, QueryAggregate, QueryUnique, Window, Register)
import qualified Database.Relational as Monadic
import qualified Database.Relational.Monad.Trans.Aggregating as Monadic
import qualified Database.Relational.Monad.Trans.Ordering as Monadic
import qualified Database.Relational.Monad.Trans.Assigning as Monadic
newtype QueryA m a b = QueryA (Kleisli m a b) deriving (Category, Arrow)
queryA :: (a -> m b) -> QueryA m a b
queryA = QueryA . Kleisli
runQueryA :: QueryA m a b -> a -> m b
runQueryA (QueryA k) = runKleisli k
runAofM :: (m b -> c) -> QueryA m () b -> c
runAofM = (. (`runQueryA` ()))
type QuerySimple = QueryA Monadic.QuerySimple
type QueryAggregate = QueryA Monadic.QueryAggregate
type QueryUnique = QueryA Monadic.QueryUnique
type AggregatingSet = QueryA Monadic.AggregatingSet
type AggregatingSetList = QueryA Monadic.AggregatingSetList
type AggregatingPowerSet = QueryA Monadic.AggregatingPowerSet
type Orderings c m = QueryA (Monadic.Orderings c m)
type Window c = QueryA (Monadic.Window c)
type Assignings r m = QueryA (Monadic.Assignings r m)
type AssignStatement r a = Assignings r Restrict (Record Flat r) a
type Register r a = QueryA (Monadic.Register r) () a
type RestrictedStatement r a = QueryA Monadic.Restrict (Record Flat r) a
all' :: MonadQuery m => QueryA m () ()
all' = queryA $ \() -> Monadic.all'
distinct :: MonadQuery m => QueryA m () ()
distinct = queryA $ \() -> Monadic.distinct
query :: (MonadQualify ConfigureQuery m, MonadQuery m)
=> Relation () r -> QueryA m () (Record Flat r)
query r = queryA $ \() -> Monadic.query r
queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m)
=> Relation () r -> QueryA m () (Record Flat (Maybe r))
queryMaybe r = queryA $ \() -> Monadic.queryMaybe r
query' :: (MonadQualify ConfigureQuery m, MonadQuery m)
=> Relation p r -> QueryA m () (PlaceHolders p, Record Flat r)
query' r = queryA $ \() -> Monadic.query' r
queryMaybe' :: (MonadQualify ConfigureQuery m, MonadQuery m)
=> Relation p r -> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
queryMaybe' r = queryA $ \() -> Monadic.queryMaybe' r
unsafeQueryList :: MonadQualify ConfigureQuery m
=> (a -> Relation () r)
-> QueryA m a (RecordList (Record c) r)
unsafeQueryList rf = queryA $ Monadic.queryList . rf
unsafeQueryList' :: MonadQualify ConfigureQuery m
=> (a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' rf = queryA $ Monadic.queryList' . rf
queryList :: MonadQualify ConfigureQuery m
=> (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record c) r)
queryList = unsafeQueryList
queryList' :: MonadQualify ConfigureQuery m
=> (Record c a -> Relation p r)
-> QueryA m (Record c a) (PlaceHolders p, RecordList (Record c) r)
queryList' = unsafeQueryList'
queryExists :: MonadQualify ConfigureQuery m
=> (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record Exists) r)
queryExists = unsafeQueryList
queryExists' :: MonadQualify ConfigureQuery m
=> (Record c a -> Relation p r)
-> QueryA m (Record c a) (PlaceHolders p, RecordList (Record Exists) r)
queryExists' = unsafeQueryList'
queryListU :: MonadQualify ConfigureQuery m
=> Relation () r
-> QueryA m () (RecordList (Record c) r)
queryListU r = unsafeQueryList $ \() -> r
queryListU' :: MonadQualify ConfigureQuery m
=> Relation p r
-> QueryA m () (PlaceHolders p, RecordList (Record c) r)
queryListU' r = unsafeQueryList' $ \() -> r
unsafeQueryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> (a -> UniqueRelation () c r)
-> QueryA m a (Record c (Maybe r))
unsafeQueryScalar rf = queryA $ Monadic.queryScalar . rf
unsafeQueryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> (a -> UniqueRelation p c r)
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar' rf = queryA $ Monadic.queryScalar' . rf
queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> (Record c a -> UniqueRelation () c r)
-> QueryA m (Record c a) (Record c (Maybe r))
queryScalar = unsafeQueryScalar
queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> (Record c a -> UniqueRelation p c r)
-> QueryA m (Record c a) (PlaceHolders p, Record c (Maybe r))
queryScalar' = unsafeQueryScalar'
queryScalarU :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> UniqueRelation () c r
-> QueryA m () (Record c (Maybe r))
queryScalarU r = unsafeQueryScalar $ \() -> r
queryScalarU' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
=> UniqueRelation p c r
-> QueryA m () (PlaceHolders p, Record c (Maybe r))
queryScalarU' r = unsafeQueryScalar' $ \() -> r
uniqueQuery' :: UniqueRelation p c r
-> QueryA Monadic.QueryUnique () (PlaceHolders p, Record c r)
uniqueQuery' r = queryA $ \() -> Monadic.uniqueQuery' r
uniqueQueryMaybe' :: UniqueRelation p c r
-> QueryA Monadic.QueryUnique () (PlaceHolders p, Record c (Maybe r))
uniqueQueryMaybe' r = queryA $ \() -> Monadic.uniqueQueryMaybe' r
on :: MonadQuery m
=> QueryA m (Predicate Flat) ()
on = queryA Monadic.on
wheres :: MonadRestrict Flat m
=> QueryA m (Predicate Flat) ()
wheres = queryA Monadic.wheres
having :: MonadRestrict Aggregated m
=> QueryA m (Predicate Aggregated) ()
having = queryA Monadic.having
groupBy :: MonadAggregate m
=> QueryA m (Record Flat r) (Record Aggregated r)
groupBy = queryA Monadic.groupBy
placeholder :: (PersistableWidth t, SqlContext c, Monad m)
=> QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
placeholder = queryA $ Monadic.placeholder . runQueryA
relation :: QuerySimple () (Record Flat r)
-> Relation () r
relation = runAofM Monadic.relation
relation' :: QuerySimple () (PlaceHolders p, Record Flat r)
-> Relation p r
relation' = runAofM Monadic.relation'
aggregateRelation :: QueryAggregate () (Record Aggregated r)
-> Relation () r
aggregateRelation = runAofM Monadic.aggregateRelation
aggregateRelation' :: QueryAggregate () (PlaceHolders p, Record Aggregated r)
-> Relation p r
aggregateRelation' = runAofM Monadic.aggregateRelation'
uniqueRelation' :: QueryUnique () (PlaceHolders p, Record c r)
-> UniqueRelation p c r
uniqueRelation' = runAofM Monadic.uniqueRelation'
groupBy' :: MonadAggregate m => QueryA m (AggregateKey (Record Aggregated r)) (Record Aggregated r)
groupBy' = queryA Monadic.groupBy'
key :: AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))
key = queryA Monadic.key
key' :: AggregatingSet (AggregateKey a) a
key' = queryA Monadic.key'
set :: AggregatingSetList (AggregatingSet () a) a
set = queryA $ runAofM Monadic.set
bkey :: AggregatingPowerSet (Record Flat r) (Record Aggregated (Maybe r))
bkey = queryA Monadic.bkey
rollup :: AggregatingPowerSet () a -> AggregateKey a
rollup = runAofM Monadic.rollup
cube :: AggregatingPowerSet () a -> AggregateKey a
cube = runAofM Monadic.cube
groupingSets :: AggregatingSetList () a -> AggregateKey a
groupingSets = runAofM Monadic.groupingSets
orderBy' :: Monad m
=> Order
-> Nulls
-> Orderings c m (Record c t) ()
orderBy' o n = queryA $ \p -> Monadic.orderBy' p o n
orderBy :: Monad m
=> Order
-> Orderings c m (Record c t) ()
orderBy o = queryA (`Monadic.orderBy` o)
asc :: Monad m
=> Orderings c m (Record c t) ()
asc = queryA Monadic.asc
desc :: Monad m
=> Orderings c m (Record c t) ()
desc = queryA Monadic.desc
partitionBy :: Window c (Record c r) ()
partitionBy = queryA Monadic.partitionBy
over :: SqlContext c
=> Record OverWindow a -> Window c () () -> Record c a
over po = runAofM $ Monadic.over po
infix 8 `over`
assign :: Monad m
=> Monadic.AssignTarget r v
-> Assignings r m (Record Flat v) ()
assign t = queryA (`Monadic.assignTo` t)
update' :: TableDerivable r => Config -> AssignStatement r (PlaceHolders p) -> Update p
update' config = Monadic.update' config . runQueryA
update :: TableDerivable r => AssignStatement r (PlaceHolders p) -> Update p
update = Monadic.update . runQueryA
updateNoPH :: TableDerivable r => AssignStatement r () -> Update ()
updateNoPH = Monadic.updateNoPH . runQueryA
updateAllColumn' :: (PersistableWidth r, TableDerivable r)
=> Config
-> RestrictedStatement r (PlaceHolders p)
-> Update (r, p)
updateAllColumn' config = Monadic.updateAllColumn' config . runQueryA
updateAllColumn :: (PersistableWidth r, TableDerivable r)
=> RestrictedStatement r (PlaceHolders p)
-> Update (r, p)
updateAllColumn = Monadic.updateAllColumn . runQueryA
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r)
=> RestrictedStatement r ()
-> Update r
updateAllColumnNoPH = Monadic.updateAllColumnNoPH . runQueryA
insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
insertValue' config = Monadic.insertValue' config . ($ ()) . runQueryA
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
insertValue = Monadic.insertValue . ($ ()) . runQueryA
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()
insertValueNoPH = Monadic.insertValueNoPH . ($ ()) . runQueryA
delete' :: TableDerivable r => Config -> RestrictedStatement r (PlaceHolders p) -> Delete p
delete' config = Monadic.delete' config . runQueryA
delete :: TableDerivable r => RestrictedStatement r (PlaceHolders p) -> Delete p
delete = Monadic.delete . runQueryA
deleteNoPH :: TableDerivable r => RestrictedStatement r () -> Delete ()
deleteNoPH = Monadic.deleteNoPH . runQueryA
{-# DEPRECATED derivedUpdate' "use `update'` instead of this." #-}
derivedUpdate' :: TableDerivable r => Config -> AssignStatement r (PlaceHolders p) -> Update p
derivedUpdate' = update'
{-# DEPRECATED derivedUpdate "use `update` instead of this." #-}
derivedUpdate :: TableDerivable r => AssignStatement r (PlaceHolders p) -> Update p
derivedUpdate = update
{-# DEPRECATED derivedInsertValue' "use `insertValue'` instead of this." #-}
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' = insertValue'
{-# DEPRECATED derivedInsertValue "use `insertValue` instead of this." #-}
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
derivedInsertValue = insertValue
{-# DEPRECATED derivedDelete' "use `derivedDelete'` instead of this." #-}
derivedDelete' :: TableDerivable r => Config -> RestrictedStatement r (PlaceHolders p) -> Delete p
derivedDelete' = delete'
{-# DEPRECATED derivedDelete "use `derivedDelete` instead of this." #-}
derivedDelete :: TableDerivable r => RestrictedStatement r (PlaceHolders p) -> Delete p
derivedDelete = delete