{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- |
-- Module      : Database.Relational.Arrow
-- Copyright   : 2015-2019 Kei Hibino
-- License     : BSD3
--
-- Maintainer  : ex8k.hibino@gmail.com
-- Stability   : experimental
-- Portability : unknown
--
-- This module defines arrow version combinators which
-- improves type-safety on building queries.
-- Referencing the local projected records may cause to break
-- the result query.
-- It is possible to controls injection of previous local projected records
-- by restricting domain type of arrow. This idea is imported from Opaleye:
--
--   * <https://github.com/tomjaguarpaw/haskell-opaleye>
--   * <https://github.com/khibino/haskell-relational-record/issues/19>
--
-- Importing this module instead of "Database.Relational.Query" enables
-- to build query using arrow combinators.
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,

  -- * Deprecated
  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


-- | Arrow to build queries.
newtype QueryA m a b = QueryA (Kleisli m a b) deriving (forall a. QueryA m a a
forall b c a. QueryA m b c -> QueryA m a b -> QueryA m a c
forall {k} (cat :: k -> k -> *).
(forall (a :: k). cat a a)
-> (forall (b :: k) (c :: k) (a :: k).
    cat b c -> cat a b -> cat a c)
-> Category cat
forall (m :: * -> *) a. Monad m => QueryA m a a
forall (m :: * -> *) b c a.
Monad m =>
QueryA m b c -> QueryA m a b -> QueryA m a c
. :: forall b c a. QueryA m b c -> QueryA m a b -> QueryA m a c
$c. :: forall (m :: * -> *) b c a.
Monad m =>
QueryA m b c -> QueryA m a b -> QueryA m a c
id :: forall a. QueryA m a a
$cid :: forall (m :: * -> *) a. Monad m => QueryA m a a
Category, forall b c. (b -> c) -> QueryA m b c
forall b c d. QueryA m b c -> QueryA m (b, d) (c, d)
forall b c d. QueryA m b c -> QueryA m (d, b) (d, c)
forall b c c'. QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
forall b c b' c'.
QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c')
forall (m :: * -> *). Monad m => Category (QueryA m)
forall (m :: * -> *) b c. Monad m => (b -> c) -> QueryA m b c
forall (m :: * -> *) b c d.
Monad m =>
QueryA m b c -> QueryA m (b, d) (c, d)
forall (m :: * -> *) b c d.
Monad m =>
QueryA m b c -> QueryA m (d, b) (d, c)
forall (m :: * -> *) b c c'.
Monad m =>
QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
forall (m :: * -> *) b c b' c'.
Monad m =>
QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c')
forall (a :: * -> * -> *).
Category a
-> (forall b c. (b -> c) -> a b c)
-> (forall b c d. a b c -> a (b, d) (c, d))
-> (forall b c d. a b c -> a (d, b) (d, c))
-> (forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c'))
-> (forall b c c'. a b c -> a b c' -> a b (c, c'))
-> Arrow a
&&& :: forall b c c'. QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
$c&&& :: forall (m :: * -> *) b c c'.
Monad m =>
QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
*** :: forall b c b' c'.
QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c')
$c*** :: forall (m :: * -> *) b c b' c'.
Monad m =>
QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c')
second :: forall b c d. QueryA m b c -> QueryA m (d, b) (d, c)
$csecond :: forall (m :: * -> *) b c d.
Monad m =>
QueryA m b c -> QueryA m (d, b) (d, c)
first :: forall b c d. QueryA m b c -> QueryA m (b, d) (c, d)
$cfirst :: forall (m :: * -> *) b c d.
Monad m =>
QueryA m b c -> QueryA m (b, d) (c, d)
arr :: forall b c. (b -> c) -> QueryA m b c
$carr :: forall (m :: * -> *) b c. Monad m => (b -> c) -> QueryA m b c
Arrow)

queryA :: (a -> m b) -> QueryA m a b
queryA :: forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA = forall (m :: * -> *) a b. Kleisli m a b -> QueryA m a b
QueryA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. (a -> m b) -> Kleisli m a b
Kleisli

runQueryA :: QueryA m a b -> a -> m b
runQueryA :: forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA (QueryA Kleisli m a b
k) = forall (m :: * -> *) a b. Kleisli m a b -> a -> m b
runKleisli Kleisli m a b
k

runAofM :: (m b -> c) -> QueryA m () b -> c
runAofM :: forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *) a b. QueryA m a b -> a -> m b
`runQueryA` ()))

-- | Arrow type corresponding to 'Monadic.QuerySimple'
type QuerySimple    = QueryA Monadic.QuerySimple

-- | Arrow type corresponding to 'Monadic.QueryAggregate'
type QueryAggregate = QueryA Monadic.QueryAggregate

-- | Arrow type corresponding to 'Monadic.QueryUnique'
type QueryUnique = QueryA Monadic.QueryUnique

-- | Arrow type corresponding to 'Monadic.AggregatingSet'
type AggregatingSet = QueryA Monadic.AggregatingSet

-- | Arrow type corresponding to 'Monadic.AggregatingSetList'
type AggregatingSetList = QueryA Monadic.AggregatingSetList

-- | Arrow type corresponding to 'Monadic.AggregatingPowerSet'
type AggregatingPowerSet = QueryA Monadic.AggregatingPowerSet

-- | Arrow type corresponding to 'Monadic.Orderings'
type Orderings c m = QueryA (Monadic.Orderings c m)

-- | Arrow type corresponding to 'Monadic.Window'
type Window c = QueryA (Monadic.Window c)

-- | Arrow type corresponding to 'Monadic.Assignings'
type Assignings r m = QueryA (Monadic.Assignings r m)

-- | Arrow type corresponding to 'Monadic.AssignStatement'
type AssignStatement r a = QueryA (Monadic.Assignings r Restrict) (Record Flat r) a

-- | Arrow type corresponding to 'Monadic.Register'
type Register r a = QueryA (Monadic.Register r) () a

-- | Arrow type corresponding to 'Monadic.RestrictedStatement'
type RestrictedStatement r a = QueryA Monadic.Restrict (Record Flat r) a


-- | Same as 'Monadic.all''. Arrow version.
all' :: MonadQuery m => QueryA m () ()
all' :: forall (m :: * -> *). MonadQuery m => QueryA m () ()
all' = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *). MonadQuery m => m ()
Monadic.all'

-- | Same as 'Monadic.distinct'. Arrow version.
distinct :: MonadQuery m => QueryA m () ()
distinct :: forall (m :: * -> *). MonadQuery m => QueryA m () ()
distinct = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *). MonadQuery m => m ()
Monadic.distinct

-- | Same as 'Monadic.query'. Arrow version.
--   The result arrow is not injected by local projected records.
query :: (MonadQualify ConfigureQuery m, MonadQuery m)
      => Relation () r -> QueryA m () (Record Flat r)
query :: forall (m :: * -> *) r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation () r -> QueryA m () (Record Flat r)
query Relation () r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *) r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation () r -> m (Record Flat r)
Monadic.query Relation () r
r

-- | Same as 'Monadic.queryMaybe'. Arrow version.
--   The result arrow is not injected by any local projected records.
queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m)
           => Relation () r -> QueryA m () (Record Flat (Maybe r))
queryMaybe :: forall (m :: * -> *) r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation () r -> QueryA m () (Record Flat (Maybe r))
queryMaybe Relation () r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *) r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation () r -> m (Record Flat (Maybe r))
Monadic.queryMaybe Relation () r
r

-- | Same as 'Monadic.query''. Arrow version.
--   The result arrow is not injected by any local projected records.
query' :: (MonadQualify ConfigureQuery m, MonadQuery m)
       => Relation p r -> QueryA m () (PlaceHolders p, Record Flat r)
query' :: forall (m :: * -> *) p r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation p r -> QueryA m () (PlaceHolders p, Record Flat r)
query' Relation p r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *) p r.
MonadQuery m =>
Relation p r -> m (PlaceHolders p, Record Flat r)
Monadic.query' Relation p r
r

-- | Same as 'Monadic.queryMaybe''. Arrow version.
--   The result arrow is not injected by any local projected records.
queryMaybe' :: (MonadQualify ConfigureQuery m, MonadQuery m)
            => Relation p r -> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
queryMaybe' :: forall (m :: * -> *) p r.
(MonadQualify ConfigureQuery m, MonadQuery m) =>
Relation p r -> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
queryMaybe' Relation p r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall (m :: * -> *) p r.
MonadQuery m =>
Relation p r -> m (PlaceHolders p, Record Flat (Maybe r))
Monadic.queryMaybe' Relation p r
r

unsafeQueryList :: MonadQualify ConfigureQuery m
            => (a -> Relation () r)
            -> QueryA m a (RecordList (Record c) r)
unsafeQueryList :: forall (m :: * -> *) a r c.
MonadQualify ConfigureQuery m =>
(a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList a -> Relation () r
rf = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r c.
MonadQualify ConfigureQuery m =>
Relation () r -> m (RecordList (Record c) r)
Monadic.queryList forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Relation () r
rf

unsafeQueryList' :: MonadQualify ConfigureQuery m
             => (a -> Relation p r)
             -> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' :: forall (m :: * -> *) a p r c.
MonadQualify ConfigureQuery m =>
(a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' a -> Relation p r
rf = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) p r c.
MonadQualify ConfigureQuery m =>
Relation p r -> m (PlaceHolders p, RecordList (Record c) r)
Monadic.queryList' forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Relation p r
rf

-- | Same as 'Monadic.queryList'. Arrow version.
--   The result arrow is designed to be injected by local projected records.
queryList :: MonadQualify ConfigureQuery m
          => (Record c a -> Relation () r)
          -> QueryA m (Record c a) (RecordList (Record c) r)
queryList :: forall (m :: * -> *) c a r.
MonadQualify ConfigureQuery m =>
(Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record c) r)
queryList = forall (m :: * -> *) a r c.
MonadQualify ConfigureQuery m =>
(a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList

-- | Same as 'Monadic.queryList''. Arrow version.
--   The result arrow is designed to be injected by local projected records.
queryList' :: MonadQualify ConfigureQuery m
           => (Record c a -> Relation p r)
           -> QueryA m (Record c a) (PlaceHolders p, RecordList (Record c) r)
queryList' :: forall (m :: * -> *) c a p r.
MonadQualify ConfigureQuery m =>
(Record c a -> Relation p r)
-> QueryA m (Record c a) (PlaceHolders p, RecordList (Record c) r)
queryList' = forall (m :: * -> *) a p r c.
MonadQualify ConfigureQuery m =>
(a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList'

-- | Same as 'Monadic.queryList' to pass this result to 'exists' operator. Arrow version.
--   The result arrow is designed to be injected by local projected records.
queryExists :: MonadQualify ConfigureQuery m
          => (Record c a -> Relation () r)
          -> QueryA m (Record c a) (RecordList (Record Exists) r)
queryExists :: forall (m :: * -> *) c a r.
MonadQualify ConfigureQuery m =>
(Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record Exists) r)
queryExists = forall (m :: * -> *) a r c.
MonadQualify ConfigureQuery m =>
(a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList

-- | Same as 'Monadic.queryList'' to pass this result to 'exists' operator. Arrow version.
--   The result arrow is designed to be injected by local projected records.
queryExists' :: MonadQualify ConfigureQuery m
           => (Record c a -> Relation p r)
           -> QueryA m (Record c a) (PlaceHolders p, RecordList (Record Exists) r)
queryExists' :: forall (m :: * -> *) c a p r.
MonadQualify ConfigureQuery m =>
(Record c a -> Relation p r)
-> QueryA
     m (Record c a) (PlaceHolders p, RecordList (Record Exists) r)
queryExists' = forall (m :: * -> *) a p r c.
MonadQualify ConfigureQuery m =>
(a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList'

-- | Same as 'Monadic.queryList'. Arrow version.
--   Useful for no reference cases to local projected records.
queryListU :: MonadQualify ConfigureQuery m
           => Relation () r
           -> QueryA m () (RecordList (Record c) r)
queryListU :: forall (m :: * -> *) r c.
MonadQualify ConfigureQuery m =>
Relation () r -> QueryA m () (RecordList (Record c) r)
queryListU Relation () r
r = forall (m :: * -> *) a r c.
MonadQualify ConfigureQuery m =>
(a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList forall a b. (a -> b) -> a -> b
$ \() -> Relation () r
r

-- | Same as 'Monadic.queryList''. Arrow version.
--   Useful for no reference cases to local projected records.
queryListU' :: MonadQualify ConfigureQuery m
           => Relation p r
           -> QueryA m () (PlaceHolders p, RecordList (Record c) r)
queryListU' :: forall (m :: * -> *) p r c.
MonadQualify ConfigureQuery m =>
Relation p r
-> QueryA m () (PlaceHolders p, RecordList (Record c) r)
queryListU' Relation p r
r = forall (m :: * -> *) a p r c.
MonadQualify ConfigureQuery m =>
(a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' forall a b. (a -> b) -> a -> b
$ \() -> Relation p r
r

unsafeQueryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r)
                  => (a -> UniqueRelation () c r)
                  -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar :: forall (m :: * -> *) r a c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation () c r) -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar a -> UniqueRelation () c r
rf = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation () c r -> m (Record c (Maybe r))
Monadic.queryScalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> UniqueRelation () c r
rf

unsafeQueryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
                   => (a -> UniqueRelation p c r)
                   -> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar' :: forall (m :: * -> *) r a p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation p c r)
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar' a -> UniqueRelation p c r
rf = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r))
Monadic.queryScalar' forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> UniqueRelation p c r
rf

-- | Same as 'Monadic.queryScalar'. Arrow version.
--   The result arrow is designed to be injected by any local projected record.
queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r)
            => (Record c a -> UniqueRelation () c r)
            -> QueryA m (Record c a) (Record c (Maybe r))
queryScalar :: forall (m :: * -> *) r c a.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(Record c a -> UniqueRelation () c r)
-> QueryA m (Record c a) (Record c (Maybe r))
queryScalar = forall (m :: * -> *) r a c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation () c r) -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar

-- | Same as 'Monadic.queryScalar''. Arrow version.
--   The result arrow is designed to be injected by any local projected record.
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' :: forall (m :: * -> *) r c a p.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(Record c a -> UniqueRelation p c r)
-> QueryA m (Record c a) (PlaceHolders p, Record c (Maybe r))
queryScalar' = forall (m :: * -> *) r a p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation p c r)
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar'

-- | Same as 'Monadic.queryScalar'. Arrow version.
--   Useful for no reference cases to local projected records.
queryScalarU :: (MonadQualify ConfigureQuery m, ScalarDegree r)
            => UniqueRelation () c r
            -> QueryA m () (Record c (Maybe r))
queryScalarU :: forall (m :: * -> *) r c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation () c r -> QueryA m () (Record c (Maybe r))
queryScalarU UniqueRelation () c r
r = forall (m :: * -> *) r a c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation () c r) -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar forall a b. (a -> b) -> a -> b
$ \() -> UniqueRelation () c r
r

-- | Same as 'Monadic.queryScalar''. Arrow version.
--   Useful for no reference cases to local projected records.
queryScalarU' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
             => UniqueRelation p c r
             -> QueryA m () (PlaceHolders p, Record c (Maybe r))
queryScalarU' :: forall (m :: * -> *) r p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation p c r
-> QueryA m () (PlaceHolders p, Record c (Maybe r))
queryScalarU' UniqueRelation p c r
r = forall (m :: * -> *) r a p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation p c r)
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar' forall a b. (a -> b) -> a -> b
$ \() -> UniqueRelation p c r
r

-- | Same as 'Monadic.uniqueQuery''. Arrow version.
--   The result arrow is not injected by local projected records.
uniqueQuery' :: UniqueRelation p c r
             -> QueryA Monadic.QueryUnique () (PlaceHolders p, Record c r)
uniqueQuery' :: forall p c r.
UniqueRelation p c r
-> QueryA QueryUnique () (PlaceHolders p, Record c r)
uniqueQuery' UniqueRelation p c r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall p c r.
UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r)
Monadic.uniqueQuery' UniqueRelation p c r
r

-- | Same as 'Monadic.uniqueQueryMaybe''. Arrow version.
--   The result arrow is not injected by local projected records.
uniqueQueryMaybe' :: UniqueRelation p c r
                  -> QueryA Monadic.QueryUnique () (PlaceHolders p, Record c (Maybe r))
uniqueQueryMaybe' :: forall p c r.
UniqueRelation p c r
-> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r))
uniqueQueryMaybe' UniqueRelation p c r
r = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \() -> forall p c r.
UniqueRelation p c r
-> QueryUnique (PlaceHolders p, Record c (Maybe r))
Monadic.uniqueQueryMaybe' UniqueRelation p c r
r

-- | Same as 'Monadic.on'. Arrow version.
--   The result arrow is designed to be injected by local conditional flat-records.
on :: MonadQuery m
   => QueryA m (Predicate Flat) ()
on :: forall (m :: * -> *). MonadQuery m => QueryA m (Predicate Flat) ()
on = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *). MonadQuery m => Predicate Flat -> m ()
Monadic.on

-- | Same as 'Monadic.wheres'. Arrow version.
--   The result arrow is designed to be injected by local conditional flat-records.
wheres :: MonadRestrict Flat m
       => QueryA m (Predicate Flat) ()
wheres :: forall (m :: * -> *).
MonadRestrict Flat m =>
QueryA m (Predicate Flat) ()
wheres = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *).
MonadRestrict Flat m =>
Predicate Flat -> m ()
Monadic.wheres

-- | Same as 'Monadic.having'. Arrow version.
--   The result arrow is designed to be injected by local conditional aggregated-records.
having :: MonadRestrict Aggregated m
       => QueryA m (Predicate Aggregated) ()
having :: forall (m :: * -> *).
MonadRestrict Aggregated m =>
QueryA m (Predicate Aggregated) ()
having = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *).
MonadRestrict Aggregated m =>
Predicate Aggregated -> m ()
Monadic.having

-- | Same as 'Monadic.groupBy'. Arrow version.
--   The result arrow is designed to be injected by local flat-records.
groupBy :: MonadAggregate m
        => QueryA m (Record Flat r) (Record Aggregated r)
groupBy :: forall (m :: * -> *) r.
MonadAggregate m =>
QueryA m (Record Flat r) (Record Aggregated r)
groupBy = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *) r.
MonadAggregate m =>
Record Flat r -> m (Record Aggregated r)
Monadic.groupBy

-- | Same as 'Monadic.placeholder'. Arrow version.
--   The result arrow is designed to be injected by locally built arrow using placeholders.
placeholder :: (PersistableWidth t, SqlContext c, Monad m)
            => QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
placeholder :: forall t c (m :: * -> *) a.
(PersistableWidth t, SqlContext c, Monad m) =>
QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
placeholder = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall t c (m :: * -> *) a.
(PersistableWidth t, SqlContext c, Monad m) =>
(Record c t -> m a) -> m (PlaceHolders t, a)
Monadic.placeholder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.relation'.
--   Finalize query-building arrow instead of query-building monad.
relation :: QuerySimple () (Record Flat r)
         -> Relation () r
relation :: forall r. QuerySimple () (Record Flat r) -> Relation () r
relation = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall r. QuerySimple (Record Flat r) -> Relation () r
Monadic.relation

-- | Same as 'Monadic.relation''.
--   Finalize query-building arrow instead of query-building monad.
relation' :: QuerySimple () (PlaceHolders p, Record Flat r)
          -> Relation p r
relation' :: forall p r.
QuerySimple () (PlaceHolders p, Record Flat r) -> Relation p r
relation' = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall p r. SimpleQuery p r -> Relation p r
Monadic.relation'

-- | Same as 'Monadic.aggregateRelation'.
--   Finalize query-building arrow instead of query-building monad.
aggregateRelation :: QueryAggregate () (Record Aggregated r)
                  -> Relation () r
aggregateRelation :: forall r. QueryAggregate () (Record Aggregated r) -> Relation () r
aggregateRelation = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall r. QueryAggregate (Record Aggregated r) -> Relation () r
Monadic.aggregateRelation

-- | Same as 'Monadic.aggregateRelation''.
--   Finalize query-building arrow instead of query-building monad.
aggregateRelation' :: QueryAggregate () (PlaceHolders p, Record Aggregated r)
                   -> Relation p r
aggregateRelation' :: forall p r.
QueryAggregate () (PlaceHolders p, Record Aggregated r)
-> Relation p r
aggregateRelation' = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall p r. AggregatedQuery p r -> Relation p r
Monadic.aggregateRelation'

-- | Same as 'Monadic.uniqueRelation''.
--   Finalize query-building arrow instead of query-building monad.
uniqueRelation' :: QueryUnique () (PlaceHolders p, Record c r)
                -> UniqueRelation p c r
uniqueRelation' :: forall p c r.
QueryUnique () (PlaceHolders p, Record c r) -> UniqueRelation p c r
uniqueRelation' = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall p c r.
QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r
Monadic.uniqueRelation'

-- | Same as 'Monadic.groupBy''.
--   This arrow is designed to be injected by local 'AggregateKey'.
groupBy' :: MonadAggregate m => QueryA m (AggregateKey (Record Aggregated r)) (Record Aggregated r)
groupBy' :: forall (m :: * -> *) r.
MonadAggregate m =>
QueryA m (AggregateKey (Record Aggregated r)) (Record Aggregated r)
groupBy' = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *) r.
MonadAggregate m =>
AggregateKey (Record Aggregated r) -> m (Record Aggregated r)
Monadic.groupBy'

-- | Same as 'Monadic.key'.
--   This arrow is designed to be injected by local flat-records.
key :: AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))
key :: forall r.
AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))
key = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall r.
Record Flat r -> AggregatingSet (Record Aggregated (Maybe r))
Monadic.key

-- | Same as 'Monadic.key''.
--   This arrow is designed to be injected by local 'AggregteKey'.
key' :: AggregatingSet (AggregateKey a) a
key' :: forall a. AggregatingSet (AggregateKey a) a
key' = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a. AggregateKey a -> AggregatingSet a
Monadic.key'

-- | Same as 'Monadic.set'.
--   This arrow is designed to be injected by locally built 'AggregtingSet' arrow.
set :: AggregatingSetList (AggregatingSet () a) a
set :: forall a. AggregatingSetList (AggregatingSet () a) a
set = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall a. AggregatingSet a -> AggregatingSetList a
Monadic.set

-- | Same as 'Monadic.bkey'.
--   This arrow is designed to be injected by local flat-records.
bkey :: AggregatingPowerSet (Record Flat r) (Record Aggregated (Maybe r))
bkey :: forall r.
AggregatingPowerSet (Record Flat r) (Record Aggregated (Maybe r))
bkey = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall r.
Record Flat r -> AggregatingPowerSet (Record Aggregated (Maybe r))
Monadic.bkey

-- | Same as 'Monadic.rollup'.
--   Finalize locally built 'AggregatingPowerSet'.
rollup :: AggregatingPowerSet () a -> AggregateKey a
rollup :: forall a. AggregatingPowerSet () a -> AggregateKey a
rollup = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall a. AggregatingPowerSet a -> AggregateKey a
Monadic.rollup

-- | Same as 'Monadic.cube'.
--   Finalize locally built 'AggregatingPowerSet'.
cube :: AggregatingPowerSet () a -> AggregateKey a
cube :: forall a. AggregatingPowerSet () a -> AggregateKey a
cube = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall a. AggregatingPowerSet a -> AggregateKey a
Monadic.cube

-- | Same as 'Monadic.groupingSets'.
--   Finalize locally built 'AggregatingSetList'.
groupingSets :: AggregatingSetList () a -> AggregateKey a
groupingSets :: forall a. AggregatingSetList () a -> AggregateKey a
groupingSets = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall a. AggregatingSetList a -> AggregateKey a
Monadic.groupingSets

-- | Same as 'Monadic.orderBy''.
--   The result arrow is designed to be injected by local projected records.
orderBy' :: Monad m
         => Order
         -> Nulls
         -> Orderings c m (Record c t) ()
orderBy' :: forall (m :: * -> *) c t.
Monad m =>
Order -> Nulls -> Orderings c m (Record c t) ()
orderBy' Order
o Nulls
n = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall a b. (a -> b) -> a -> b
$ \Record c t
p -> forall (m :: * -> *) c t.
Monad m =>
Record c t -> Order -> Nulls -> Orderings c m ()
Monadic.orderBy' Record c t
p Order
o Nulls
n

-- | Same as 'Monadic.orderBy'.
--   The result arrow is designed to be injected by local projected records.
orderBy :: Monad m
        => Order
        -> Orderings c m (Record c t) ()
orderBy :: forall (m :: * -> *) c t.
Monad m =>
Order -> Orderings c m (Record c t) ()
orderBy Order
o = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA (forall (m :: * -> *) c t.
Monad m =>
Record c t -> Order -> Orderings c m ()
`Monadic.orderBy` Order
o)

-- | Same as 'Monadic.asc'.
--   The result arrow is designed to be injected by local projected records.
asc :: Monad m
    => Orderings c m (Record c t) ()
asc :: forall (m :: * -> *) c t. Monad m => Orderings c m (Record c t) ()
asc = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *) c t. Monad m => Record c t -> Orderings c m ()
Monadic.asc

-- | Same as 'Monadic.desc'.
--   The result arrow is designed to be injected by local projected records.
desc :: Monad m
     => Orderings c m (Record c t) ()
desc :: forall (m :: * -> *) c t. Monad m => Orderings c m (Record c t) ()
desc = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall (m :: * -> *) c t. Monad m => Record c t -> Orderings c m ()
Monadic.desc

-- | Same as 'Monadic.partitionBy'.
--   The result arrow is designed to be injected by local projected records.
partitionBy :: Window c (Record c r) ()
partitionBy :: forall c r. Window c (Record c r) ()
partitionBy = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA forall c (m :: * -> *) r. MonadPartition c m => Record c r -> m ()
Monadic.partitionBy

-- | Same as 'Monadic.over'.
--   Make record of window function result using built 'Window' arrow.
over :: SqlContext c
     => Record OverWindow a -> Window c () () -> Record c a
over :: forall c a.
SqlContext c =>
Record OverWindow a -> Window c () () -> Record c a
over Record OverWindow a
po = forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM forall a b. (a -> b) -> a -> b
$ forall c a.
SqlContext c =>
Record OverWindow a -> Window c () -> Record c a
Monadic.over Record OverWindow a
po

infix 8 `over`

-- | Make 'Monadic.AssignTarget' into arrow which is designed to be
--   injected by assignees of local projected record.
assign :: Monad m
       => Monadic.AssignTarget r v
       -> Assignings r m (Record Flat v) ()
assign :: forall (m :: * -> *) r v.
Monad m =>
AssignTarget r v -> Assignings r m (Record Flat v) ()
assign AssignTarget r v
t = forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA (forall (m :: * -> *) v r.
Monad m =>
Record Flat v -> AssignTarget r v -> Assignings r m ()
`Monadic.assignTo` AssignTarget r v
t)

-- | Same as 'Monadic.update''.
--   Make 'Update' from assigning statement arrow using configuration.
update' :: TableDerivable r => Config -> QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
update' :: forall r p.
TableDerivable r =>
Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update' Config
config = forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
Monadic.update' Config
config forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.update'.
--   Make 'Update' from assigning statement arrow.
update :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
update :: forall r p.
TableDerivable r =>
QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update = forall r p.
TableDerivable r =>
(Record Flat r -> Assign r (PlaceHolders p)) -> Update p
Monadic.update forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.updateNoPH'.
--   Make 'Update' from assigning statement arrow.
updateNoPH :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat r) () -> Update ()
updateNoPH :: forall r.
TableDerivable r =>
QueryA (Assignings r Restrict) (Record Flat r) () -> Update ()
updateNoPH = forall r.
TableDerivable r =>
(Record Flat r -> Assign r ()) -> Update ()
Monadic.updateNoPH forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.updateAllColumn''.
--   Make 'Update' from restrected statement arrow.
updateAllColumn' :: (PersistableWidth r, TableDerivable r)
                 => Config
                 -> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p)
                 -> Update (r, p)
updateAllColumn' :: forall r p.
(PersistableWidth r, TableDerivable r) =>
Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
updateAllColumn' Config
config = forall r p.
(PersistableWidth r, TableDerivable r) =>
Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
Monadic.updateAllColumn' Config
config forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.updateAllColumn'.
--   Make 'Update' from restrected statement arrow.
updateAllColumn :: (PersistableWidth r, TableDerivable r)
                => QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p)
                -> Update (r, p)
updateAllColumn :: forall r p.
(PersistableWidth r, TableDerivable r) =>
QueryA Restrict (Record Flat r) (PlaceHolders p) -> Update (r, p)
updateAllColumn = forall r p.
(PersistableWidth r, TableDerivable r) =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
Monadic.updateAllColumn forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.updateAllColumnNoPH'.
--   Make 'Update' from restrected statement arrow.
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r)
                    => QueryA Monadic.Restrict (Record Flat r) ()
                    -> Update r
updateAllColumnNoPH :: forall r.
(PersistableWidth r, TableDerivable r) =>
QueryA Restrict (Record Flat r) () -> Update r
updateAllColumnNoPH = forall r.
(PersistableWidth r, TableDerivable r) =>
(Record Flat r -> Restrict ()) -> Update r
Monadic.updateAllColumnNoPH forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.insertValue''.
--   Make 'Insert' from register arrow using configuration.
insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
insertValue' :: forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
insertValue' Config
config = forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
Monadic.insertValue' Config
config forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ ()) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.insertValue'.
--   Make 'Insert' from register arrow.
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
insertValue :: forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
insertValue = forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
Monadic.insertValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ ()) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.insertValueNoPH'.
--   Make 'Insert' from register arrow.
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()
insertValueNoPH :: forall r. TableDerivable r => Register r () -> Insert ()
insertValueNoPH = forall r. TableDerivable r => Register r () -> Insert ()
Monadic.insertValueNoPH forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ ()) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA


-- | Same as 'Monadic.delete''.
--   Make 'Update' from restrict statement arrow using configuration.
delete' :: TableDerivable r => Config -> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete' :: forall r p.
TableDerivable r =>
Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete' Config
config = forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
Monadic.delete' Config
config forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.delete'.
--   Make 'Update' from restrict statement arrow.
delete :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete :: forall r p.
TableDerivable r =>
QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete = forall r p.
TableDerivable r =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
Monadic.delete forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

-- | Same as 'Monadic.deleteNoPH'.
--   Make 'Update' from restrict statement arrow.
deleteNoPH :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) () -> Delete ()
deleteNoPH :: forall r.
TableDerivable r =>
QueryA Restrict (Record Flat r) () -> Delete ()
deleteNoPH = forall r.
TableDerivable r =>
(Record Flat r -> Restrict ()) -> Delete ()
Monadic.deleteNoPH forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a b. QueryA m a b -> a -> m b
runQueryA

{-# DEPRECATED derivedUpdate' "use `update'` instead of this." #-}
-- | Same as 'Monadic.update''.
--   Make 'Update' from assigning statement arrow using configuration.
derivedUpdate' :: TableDerivable r => Config -> QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
derivedUpdate' :: forall r p.
TableDerivable r =>
Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
derivedUpdate' = forall r p.
TableDerivable r =>
Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update'

{-# DEPRECATED derivedUpdate "use `update` instead of this." #-}
-- | Deprecated.
derivedUpdate :: TableDerivable r => QueryA (Monadic.Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p
derivedUpdate :: forall r p.
TableDerivable r =>
QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
derivedUpdate = forall r p.
TableDerivable r =>
QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update

{-# DEPRECATED derivedInsertValue' "use `insertValue'` instead of this." #-}
-- | Deprecated.
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' :: forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' = forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
insertValue'

{-# DEPRECATED derivedInsertValue "use `insertValue` instead of this." #-}
-- | Deprecated.
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
derivedInsertValue :: forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
derivedInsertValue = forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
insertValue

{-# DEPRECATED derivedDelete' "use `derivedDelete'` instead of this." #-}
-- | Deprecated.
derivedDelete' :: TableDerivable r => Config -> QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete' :: forall r p.
TableDerivable r =>
Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete' = forall r p.
TableDerivable r =>
Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete'

{-# DEPRECATED derivedDelete "use `derivedDelete` instead of this." #-}
-- | Deprecated.
derivedDelete :: TableDerivable r => QueryA Monadic.Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete :: forall r p.
TableDerivable r =>
QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete = forall r p.
TableDerivable r =>
QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete