{-# 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, Orderings, Window, Register)
import qualified Database.Relational as Monadic
import qualified Database.Relational.Monad.Trans.Aggregating 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 = QueryA (Monadic.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 -> QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
update' config = Monadic.update' config . runQueryA
update :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
update = Monadic.update . runQueryA
updateNoPH :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat r) () -> Update ()
updateNoPH = Monadic.updateNoPH . runQueryA
updateAllColumn' :: (PersistableWidth r, TableDerivable r)
=> Config
-> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
updateAllColumn' config = Monadic.updateAllColumn' config . runQueryA
updateAllColumn :: (PersistableWidth r, TableDerivable r)
=> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
updateAllColumn = Monadic.updateAllColumn . runQueryA
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r)
=> QueryA Monadic.Restrict (Record Flat 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 -> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete' config = Monadic.delete' config . runQueryA
delete :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete = Monadic.delete . runQueryA
deleteNoPH :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) () -> Delete ()
deleteNoPH = Monadic.deleteNoPH . runQueryA
{-# DEPRECATED derivedUpdate' "use `update'` instead of this." #-}
derivedUpdate' :: TableDerivable r => Config -> QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
derivedUpdate' = update'
{-# DEPRECATED derivedUpdate "use `update` instead of this." #-}
derivedUpdate :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat 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 -> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete' = delete'
{-# DEPRECATED derivedDelete "use `derivedDelete` instead of this." #-}
derivedDelete :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete = delete