{-# 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-safty 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 (QueryA m a a
QueryA m b c -> QueryA m a b -> QueryA m a c
(forall a. QueryA m a a)
-> (forall b c a. QueryA m b c -> QueryA m a b -> QueryA m a c)
-> Category (QueryA m)
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
. :: 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 :: QueryA m a a
$cid :: forall (m :: * -> *) a. Monad m => QueryA m a a
Category, Category (QueryA m)
Category (QueryA m)
-> (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 b' c'.
    QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c'))
-> (forall b c c'.
    QueryA m b c -> QueryA m b c' -> QueryA m b (c, c'))
-> Arrow (QueryA m)
QueryA m b c -> QueryA m (b, d) (c, d)
QueryA m b c -> QueryA m (d, b) (d, c)
QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c')
QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
(b -> c) -> QueryA m b c
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
&&& :: 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')
*** :: 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 :: 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 :: 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 :: (b -> c) -> QueryA m b c
$carr :: forall (m :: * -> *) b c. Monad m => (b -> c) -> QueryA m b c
$cp1Arrow :: forall (m :: * -> *). Monad m => Category (QueryA m)
Arrow)

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

runQueryA :: QueryA m a b -> a -> m b
runQueryA :: QueryA m a b -> a -> m b
runQueryA (QueryA Kleisli m a b
k) = Kleisli m a b -> a -> m b
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 :: (m b -> c) -> QueryA m () b -> c
runAofM = ((m b -> c) -> (QueryA m () b -> m b) -> QueryA m () b -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (QueryA m () b -> () -> m b
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' :: QueryA m () ()
all' = (() -> m ()) -> QueryA m () ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m ()) -> QueryA m () ()) -> (() -> m ()) -> QueryA m () ()
forall a b. (a -> b) -> a -> b
$ \() -> m ()
forall (m :: * -> *). MonadQuery m => m ()
Monadic.all'

-- | Same as 'Monadic.distinct'. Arrow version.
distinct :: MonadQuery m => QueryA m () ()
distinct :: QueryA m () ()
distinct = (() -> m ()) -> QueryA m () ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m ()) -> QueryA m () ()) -> (() -> m ()) -> QueryA m () ()
forall a b. (a -> b) -> a -> b
$ \() -> m ()
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 :: Relation () r -> QueryA m () (Record Flat r)
query Relation () r
r = (() -> m (Record Flat r)) -> QueryA m () (Record Flat r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m (Record Flat r)) -> QueryA m () (Record Flat r))
-> (() -> m (Record Flat r)) -> QueryA m () (Record Flat r)
forall a b. (a -> b) -> a -> b
$ \() -> Relation () r -> m (Record Flat r)
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 :: Relation () r -> QueryA m () (Record Flat (Maybe r))
queryMaybe Relation () r
r = (() -> m (Record Flat (Maybe r)))
-> QueryA m () (Record Flat (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m (Record Flat (Maybe r)))
 -> QueryA m () (Record Flat (Maybe r)))
-> (() -> m (Record Flat (Maybe r)))
-> QueryA m () (Record Flat (Maybe r))
forall a b. (a -> b) -> a -> b
$ \() -> Relation () r -> m (Record Flat (Maybe r))
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' :: Relation p r -> QueryA m () (PlaceHolders p, Record Flat r)
query' Relation p r
r = (() -> m (PlaceHolders p, Record Flat r))
-> QueryA m () (PlaceHolders p, Record Flat r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m (PlaceHolders p, Record Flat r))
 -> QueryA m () (PlaceHolders p, Record Flat r))
-> (() -> m (PlaceHolders p, Record Flat r))
-> QueryA m () (PlaceHolders p, Record Flat r)
forall a b. (a -> b) -> a -> b
$ \() -> Relation p r -> m (PlaceHolders p, Record Flat r)
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' :: Relation p r -> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
queryMaybe' Relation p r
r = (() -> m (PlaceHolders p, Record Flat (Maybe r)))
-> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> m (PlaceHolders p, Record Flat (Maybe r)))
 -> QueryA m () (PlaceHolders p, Record Flat (Maybe r)))
-> (() -> m (PlaceHolders p, Record Flat (Maybe r)))
-> QueryA m () (PlaceHolders p, Record Flat (Maybe r))
forall a b. (a -> b) -> a -> b
$ \() -> Relation p r -> m (PlaceHolders p, Record Flat (Maybe r))
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 :: (a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList a -> Relation () r
rf = (a -> m (RecordList (Record c) r))
-> QueryA m a (RecordList (Record c) r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((a -> m (RecordList (Record c) r))
 -> QueryA m a (RecordList (Record c) r))
-> (a -> m (RecordList (Record c) r))
-> QueryA m a (RecordList (Record c) r)
forall a b. (a -> b) -> a -> b
$ Relation () r -> m (RecordList (Record c) r)
forall (m :: * -> *) r c.
MonadQualify ConfigureQuery m =>
Relation () r -> m (RecordList (Record c) r)
Monadic.queryList (Relation () r -> m (RecordList (Record c) r))
-> (a -> Relation () r) -> a -> m (RecordList (Record c) r)
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' :: (a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' a -> Relation p r
rf = (a -> m (PlaceHolders p, RecordList (Record c) r))
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((a -> m (PlaceHolders p, RecordList (Record c) r))
 -> QueryA m a (PlaceHolders p, RecordList (Record c) r))
-> (a -> m (PlaceHolders p, RecordList (Record c) r))
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
forall a b. (a -> b) -> a -> b
$ Relation p r -> m (PlaceHolders p, RecordList (Record c) r)
forall (m :: * -> *) p r c.
MonadQualify ConfigureQuery m =>
Relation p r -> m (PlaceHolders p, RecordList (Record c) r)
Monadic.queryList' (Relation p r -> m (PlaceHolders p, RecordList (Record c) r))
-> (a -> Relation p r)
-> a
-> m (PlaceHolders p, RecordList (Record c) r)
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 :: (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record c) r)
queryList = (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record c) r)
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' :: (Record c a -> Relation p r)
-> QueryA m (Record c a) (PlaceHolders p, RecordList (Record c) r)
queryList' = (Record c a -> Relation p r)
-> QueryA m (Record c a) (PlaceHolders p, RecordList (Record c) r)
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 :: (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record Exists) r)
queryExists = (Record c a -> Relation () r)
-> QueryA m (Record c a) (RecordList (Record Exists) r)
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' :: (Record c a -> Relation p r)
-> QueryA
     m (Record c a) (PlaceHolders p, RecordList (Record Exists) r)
queryExists' = (Record c a -> Relation p r)
-> QueryA
     m (Record c a) (PlaceHolders p, RecordList (Record Exists) r)
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 :: Relation () r -> QueryA m () (RecordList (Record c) r)
queryListU Relation () r
r = (() -> Relation () r) -> QueryA m () (RecordList (Record c) r)
forall (m :: * -> *) a r c.
MonadQualify ConfigureQuery m =>
(a -> Relation () r) -> QueryA m a (RecordList (Record c) r)
unsafeQueryList ((() -> Relation () r) -> QueryA m () (RecordList (Record c) r))
-> (() -> Relation () r) -> QueryA m () (RecordList (Record c) r)
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' :: Relation p r
-> QueryA m () (PlaceHolders p, RecordList (Record c) r)
queryListU' Relation p r
r = (() -> Relation p r)
-> QueryA m () (PlaceHolders p, RecordList (Record c) r)
forall (m :: * -> *) a p r c.
MonadQualify ConfigureQuery m =>
(a -> Relation p r)
-> QueryA m a (PlaceHolders p, RecordList (Record c) r)
unsafeQueryList' ((() -> Relation p r)
 -> QueryA m () (PlaceHolders p, RecordList (Record c) r))
-> (() -> Relation p r)
-> QueryA m () (PlaceHolders p, RecordList (Record c) r)
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 :: (a -> UniqueRelation () c r) -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar a -> UniqueRelation () c r
rf = (a -> m (Record c (Maybe r))) -> QueryA m a (Record c (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((a -> m (Record c (Maybe r))) -> QueryA m a (Record c (Maybe r)))
-> (a -> m (Record c (Maybe r))) -> QueryA m a (Record c (Maybe r))
forall a b. (a -> b) -> a -> b
$ UniqueRelation () c r -> m (Record c (Maybe r))
forall (m :: * -> *) r c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation () c r -> m (Record c (Maybe r))
Monadic.queryScalar (UniqueRelation () c r -> m (Record c (Maybe r)))
-> (a -> UniqueRelation () c r) -> a -> m (Record c (Maybe r))
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' :: (a -> UniqueRelation p c r)
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
unsafeQueryScalar' a -> UniqueRelation p c r
rf = (a -> m (PlaceHolders p, Record c (Maybe r)))
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((a -> m (PlaceHolders p, Record c (Maybe r)))
 -> QueryA m a (PlaceHolders p, Record c (Maybe r)))
-> (a -> m (PlaceHolders p, Record c (Maybe r)))
-> QueryA m a (PlaceHolders p, Record c (Maybe r))
forall a b. (a -> b) -> a -> b
$ UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r))
forall (m :: * -> *) r p c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r))
Monadic.queryScalar' (UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r)))
-> (a -> UniqueRelation p c r)
-> a
-> m (PlaceHolders p, Record c (Maybe r))
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 :: (Record c a -> UniqueRelation () c r)
-> QueryA m (Record c a) (Record c (Maybe r))
queryScalar = (Record c a -> UniqueRelation () c r)
-> QueryA m (Record c a) (Record c (Maybe r))
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' :: (Record c a -> UniqueRelation p c r)
-> QueryA m (Record c a) (PlaceHolders p, Record c (Maybe r))
queryScalar' = (Record c a -> UniqueRelation p c r)
-> QueryA m (Record c a) (PlaceHolders p, Record c (Maybe 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'

-- | 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 :: UniqueRelation () c r -> QueryA m () (Record c (Maybe r))
queryScalarU UniqueRelation () c r
r = (() -> UniqueRelation () c r) -> QueryA m () (Record c (Maybe r))
forall (m :: * -> *) r a c.
(MonadQualify ConfigureQuery m, ScalarDegree r) =>
(a -> UniqueRelation () c r) -> QueryA m a (Record c (Maybe r))
unsafeQueryScalar ((() -> UniqueRelation () c r) -> QueryA m () (Record c (Maybe r)))
-> (() -> UniqueRelation () c r)
-> QueryA m () (Record c (Maybe r))
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' :: UniqueRelation p c r
-> QueryA m () (PlaceHolders p, Record c (Maybe r))
queryScalarU' UniqueRelation p c r
r = (() -> UniqueRelation p c r)
-> QueryA m () (PlaceHolders p, Record c (Maybe 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' ((() -> UniqueRelation p c r)
 -> QueryA m () (PlaceHolders p, Record c (Maybe r)))
-> (() -> UniqueRelation p c r)
-> QueryA m () (PlaceHolders p, Record c (Maybe r))
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' :: UniqueRelation p c r
-> QueryA QueryUnique () (PlaceHolders p, Record c r)
uniqueQuery' UniqueRelation p c r
r = (() -> QueryUnique (PlaceHolders p, Record c r))
-> QueryA QueryUnique () (PlaceHolders p, Record c r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> QueryUnique (PlaceHolders p, Record c r))
 -> QueryA QueryUnique () (PlaceHolders p, Record c r))
-> (() -> QueryUnique (PlaceHolders p, Record c r))
-> QueryA QueryUnique () (PlaceHolders p, Record c r)
forall a b. (a -> b) -> a -> b
$ \() -> UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r)
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' :: UniqueRelation p c r
-> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r))
uniqueQueryMaybe' UniqueRelation p c r
r = (() -> QueryUnique (PlaceHolders p, Record c (Maybe r)))
-> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((() -> QueryUnique (PlaceHolders p, Record c (Maybe r)))
 -> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r)))
-> (() -> QueryUnique (PlaceHolders p, Record c (Maybe r)))
-> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r))
forall a b. (a -> b) -> a -> b
$ \() -> UniqueRelation p c r
-> QueryUnique (PlaceHolders p, Record c (Maybe r))
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 :: QueryA m (Predicate Flat) ()
on = (Predicate Flat -> m ()) -> QueryA m (Predicate Flat) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Predicate Flat -> m ()
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 :: QueryA m (Predicate Flat) ()
wheres = (Predicate Flat -> m ()) -> QueryA m (Predicate Flat) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Predicate Flat -> m ()
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 :: QueryA m (Predicate Aggregated) ()
having = (Predicate Aggregated -> m ())
-> QueryA m (Predicate Aggregated) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Predicate Aggregated -> m ()
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 :: QueryA m (Record Flat r) (Record Aggregated r)
groupBy = (Record Flat r -> m (Record Aggregated r))
-> QueryA m (Record Flat r) (Record Aggregated r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record Flat r -> m (Record Aggregated r)
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 :: QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
placeholder = (QueryA m (Record c t) a -> m (PlaceHolders t, a))
-> QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((QueryA m (Record c t) a -> m (PlaceHolders t, a))
 -> QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a))
-> (QueryA m (Record c t) a -> m (PlaceHolders t, a))
-> QueryA m (QueryA m (Record c t) a) (PlaceHolders t, a)
forall a b. (a -> b) -> a -> b
$ (Record c t -> m a) -> m (PlaceHolders t, a)
forall t c (m :: * -> *) a.
(PersistableWidth t, SqlContext c, Monad m) =>
(Record c t -> m a) -> m (PlaceHolders t, a)
Monadic.placeholder ((Record c t -> m a) -> m (PlaceHolders t, a))
-> (QueryA m (Record c t) a -> Record c t -> m a)
-> QueryA m (Record c t) a
-> m (PlaceHolders t, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA m (Record c t) a -> Record c t -> m a
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 :: QuerySimple () (Record Flat r) -> Relation () r
relation = (Orderings Flat QueryCore (Record Flat r) -> Relation () r)
-> QuerySimple () (Record Flat r) -> Relation () r
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Orderings Flat QueryCore (Record Flat r) -> Relation () r
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' :: QuerySimple () (PlaceHolders p, Record Flat r) -> Relation p r
relation' = (Orderings Flat QueryCore (PlaceHolders p, Record Flat r)
 -> Relation p r)
-> QuerySimple () (PlaceHolders p, Record Flat r) -> Relation p r
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Orderings Flat QueryCore (PlaceHolders p, Record Flat r)
-> Relation p r
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 :: QueryAggregate () (Record Aggregated r) -> Relation () r
aggregateRelation = (Orderings
   Aggregated
   (Restrictings Aggregated (AggregatingSetT QueryCore))
   (Record Aggregated r)
 -> Relation () r)
-> QueryAggregate () (Record Aggregated r) -> Relation () r
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Orderings
  Aggregated
  (Restrictings Aggregated (AggregatingSetT QueryCore))
  (Record Aggregated r)
-> Relation () r
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' :: QueryAggregate () (PlaceHolders p, Record Aggregated r)
-> Relation p r
aggregateRelation' = (Orderings
   Aggregated
   (Restrictings Aggregated (AggregatingSetT QueryCore))
   (PlaceHolders p, Record Aggregated r)
 -> Relation p r)
-> QueryAggregate () (PlaceHolders p, Record Aggregated r)
-> Relation p r
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Orderings
  Aggregated
  (Restrictings Aggregated (AggregatingSetT QueryCore))
  (PlaceHolders p, Record Aggregated r)
-> Relation p r
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' :: QueryUnique () (PlaceHolders p, Record c r) -> UniqueRelation p c r
uniqueRelation' = (QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r)
-> QueryUnique () (PlaceHolders p, Record c r)
-> UniqueRelation p c r
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r
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' :: QueryA m (AggregateKey (Record Aggregated r)) (Record Aggregated r)
groupBy' = (AggregateKey (Record Aggregated r) -> m (Record Aggregated r))
-> QueryA
     m (AggregateKey (Record Aggregated r)) (Record Aggregated r)
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA AggregateKey (Record Aggregated r) -> m (Record Aggregated r)
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 :: AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))
key = (Record Flat r
 -> Aggregatings
      Set AggregateElem Identity (Record Aggregated (Maybe r)))
-> AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record Flat r
-> Aggregatings
     Set AggregateElem Identity (Record Aggregated (Maybe r))
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' :: AggregatingSet (AggregateKey a) a
key' = (AggregateKey a -> Aggregatings Set AggregateElem Identity a)
-> AggregatingSet (AggregateKey a) a
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA AggregateKey a -> Aggregatings Set AggregateElem Identity a
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 :: AggregatingSetList (AggregatingSet () a) a
set = (AggregatingSet () a
 -> Aggregatings SetList AggregateSet Identity a)
-> AggregatingSetList (AggregatingSet () a) a
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((AggregatingSet () a
  -> Aggregatings SetList AggregateSet Identity a)
 -> AggregatingSetList (AggregatingSet () a) a)
-> (AggregatingSet () a
    -> Aggregatings SetList AggregateSet Identity a)
-> AggregatingSetList (AggregatingSet () a) a
forall a b. (a -> b) -> a -> b
$ (Aggregatings Set AggregateElem Identity a
 -> Aggregatings SetList AggregateSet Identity a)
-> AggregatingSet () a
-> Aggregatings SetList AggregateSet Identity a
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Aggregatings Set AggregateElem Identity a
-> Aggregatings SetList AggregateSet Identity a
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 :: AggregatingPowerSet (Record Flat r) (Record Aggregated (Maybe r))
bkey = (Record Flat r
 -> Aggregatings
      Power AggregateBitKey Identity (Record Aggregated (Maybe r)))
-> AggregatingPowerSet
     (Record Flat r) (Record Aggregated (Maybe r))
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record Flat r
-> Aggregatings
     Power AggregateBitKey Identity (Record Aggregated (Maybe r))
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 :: AggregatingPowerSet () a -> AggregateKey a
rollup = (Aggregatings Power AggregateBitKey Identity a -> AggregateKey a)
-> AggregatingPowerSet () a -> AggregateKey a
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Aggregatings Power AggregateBitKey Identity a -> AggregateKey a
forall a. AggregatingPowerSet a -> AggregateKey a
Monadic.rollup

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

-- | Same as 'Monadic.groupingSets'.
--   Finalize locally built 'AggregatingSetList'.
groupingSets :: AggregatingSetList () a -> AggregateKey a
groupingSets :: AggregatingSetList () a -> AggregateKey a
groupingSets = (Aggregatings SetList AggregateSet Identity a -> AggregateKey a)
-> AggregatingSetList () a -> AggregateKey a
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM Aggregatings SetList AggregateSet Identity a -> AggregateKey a
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' :: Order -> Nulls -> Orderings c m (Record c t) ()
orderBy' Order
o Nulls
n = (Record c t -> Orderings c m ()) -> Orderings c m (Record c t) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA ((Record c t -> Orderings c m ()) -> Orderings c m (Record c t) ())
-> (Record c t -> Orderings c m ())
-> Orderings c m (Record c t) ()
forall a b. (a -> b) -> a -> b
$ \Record c t
p -> Record c t -> Order -> Nulls -> Orderings c m ()
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 :: Order -> Orderings c m (Record c t) ()
orderBy Order
o = (Record c t -> Orderings c m ()) -> Orderings c m (Record c t) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA (Record c t -> Order -> Orderings c m ()
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 :: Orderings c m (Record c t) ()
asc = (Record c t -> Orderings c m ()) -> Orderings c m (Record c t) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record c t -> Orderings c m ()
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 :: Orderings c m (Record c t) ()
desc = (Record c t -> Orderings c m ()) -> Orderings c m (Record c t) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record c t -> Orderings c m ()
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 :: Window c (Record c r) ()
partitionBy = (Record c r -> Window c ()) -> Window c (Record c r) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA Record c r -> Window c ()
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 :: Record OverWindow a -> Window c () () -> Record c a
over Record OverWindow a
po = (Orderings c (PartitioningSet c) () -> Record c a)
-> Window c () () -> Record c a
forall (m :: * -> *) b c. (m b -> c) -> QueryA m () b -> c
runAofM ((Orderings c (PartitioningSet c) () -> Record c a)
 -> Window c () () -> Record c a)
-> (Orderings c (PartitioningSet c) () -> Record c a)
-> Window c () ()
-> Record c a
forall a b. (a -> b) -> a -> b
$ Record OverWindow a
-> Orderings c (PartitioningSet c) () -> Record c a
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 :: AssignTarget r v -> Assignings r m (Record Flat v) ()
assign AssignTarget r v
t = (Record Flat v -> Assignings r m ())
-> Assignings r m (Record Flat v) ()
forall a (m :: * -> *) b. (a -> m b) -> QueryA m a b
queryA (Record Flat v -> AssignTarget r v -> Assignings r m ()
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' :: Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update' Config
config = Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
Monadic.update' Config
config ((Record Flat r -> Assign r (PlaceHolders p)) -> Update p)
-> (QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Assign r (PlaceHolders p))
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Assign r (PlaceHolders p)
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 :: QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
update = (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
forall r p.
TableDerivable r =>
(Record Flat r -> Assign r (PlaceHolders p)) -> Update p
Monadic.update ((Record Flat r -> Assign r (PlaceHolders p)) -> Update p)
-> (QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Assign r (PlaceHolders p))
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Assign r (PlaceHolders p)
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 :: QueryA (Assignings r Restrict) (Record Flat r) () -> Update ()
updateNoPH = (Record Flat r -> Assign r ()) -> Update ()
forall r.
TableDerivable r =>
(Record Flat r -> Assign r ()) -> Update ()
Monadic.updateNoPH ((Record Flat r -> Assign r ()) -> Update ())
-> (QueryA (Assignings r Restrict) (Record Flat r) ()
    -> Record Flat r -> Assign r ())
-> QueryA (Assignings r Restrict) (Record Flat r) ()
-> Update ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA (Assignings r Restrict) (Record Flat r) ()
-> Record Flat r -> Assign r ()
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' :: Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
updateAllColumn' Config
config = Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
forall r p.
(PersistableWidth r, TableDerivable r) =>
Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
Monadic.updateAllColumn' Config
config ((Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p))
-> (QueryA Restrict (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Restrict (PlaceHolders p))
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Restrict (PlaceHolders p)
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 :: QueryA Restrict (Record Flat r) (PlaceHolders p) -> Update (r, p)
updateAllColumn = (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
forall r p.
(PersistableWidth r, TableDerivable r) =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
Monadic.updateAllColumn ((Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p))
-> (QueryA Restrict (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Restrict (PlaceHolders p))
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Update (r, p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Restrict (PlaceHolders p)
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 :: QueryA Restrict (Record Flat r) () -> Update r
updateAllColumnNoPH = (Record Flat r -> Restrict ()) -> Update r
forall r.
(PersistableWidth r, TableDerivable r) =>
(Record Flat r -> Restrict ()) -> Update r
Monadic.updateAllColumnNoPH ((Record Flat r -> Restrict ()) -> Update r)
-> (QueryA Restrict (Record Flat r) ()
    -> Record Flat r -> Restrict ())
-> QueryA Restrict (Record Flat r) ()
-> Update r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) () -> Record Flat r -> Restrict ()
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' :: Config -> Register r (PlaceHolders p) -> Insert p
insertValue' Config
config = Config -> Register r (PlaceHolders p) -> Insert p
forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
Monadic.insertValue' Config
config (Register r (PlaceHolders p) -> Insert p)
-> (Register r (PlaceHolders p) -> Register r (PlaceHolders p))
-> Register r (PlaceHolders p)
-> Insert p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> Register r (PlaceHolders p))
-> () -> Register r (PlaceHolders p)
forall a b. (a -> b) -> a -> b
$ ()) ((() -> Register r (PlaceHolders p))
 -> Register r (PlaceHolders p))
-> (Register r (PlaceHolders p)
    -> () -> Register r (PlaceHolders p))
-> Register r (PlaceHolders p)
-> Register r (PlaceHolders p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Register r (PlaceHolders p) -> () -> Register r (PlaceHolders p)
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 :: Register r (PlaceHolders p) -> Insert p
insertValue = Register r (PlaceHolders p) -> Insert p
forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
Monadic.insertValue (Register r (PlaceHolders p) -> Insert p)
-> (Register r (PlaceHolders p) -> Register r (PlaceHolders p))
-> Register r (PlaceHolders p)
-> Insert p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> Register r (PlaceHolders p))
-> () -> Register r (PlaceHolders p)
forall a b. (a -> b) -> a -> b
$ ()) ((() -> Register r (PlaceHolders p))
 -> Register r (PlaceHolders p))
-> (Register r (PlaceHolders p)
    -> () -> Register r (PlaceHolders p))
-> Register r (PlaceHolders p)
-> Register r (PlaceHolders p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Register r (PlaceHolders p) -> () -> Register r (PlaceHolders p)
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 :: Register r () -> Insert ()
insertValueNoPH = Register r () -> Insert ()
forall r. TableDerivable r => Register r () -> Insert ()
Monadic.insertValueNoPH (Register r () -> Insert ())
-> (Register r () -> Register r ()) -> Register r () -> Insert ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> Register r ()) -> () -> Register r ()
forall a b. (a -> b) -> a -> b
$ ()) ((() -> Register r ()) -> Register r ())
-> (Register r () -> () -> Register r ())
-> Register r ()
-> Register r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Register r () -> () -> Register r ()
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' :: Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete' Config
config = Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
Monadic.delete' Config
config ((Record Flat r -> Restrict (PlaceHolders p)) -> Delete p)
-> (QueryA Restrict (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Restrict (PlaceHolders p))
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Delete p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Restrict (PlaceHolders p)
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 :: QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete = (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
forall r p.
TableDerivable r =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
Monadic.delete ((Record Flat r -> Restrict (PlaceHolders p)) -> Delete p)
-> (QueryA Restrict (Record Flat r) (PlaceHolders p)
    -> Record Flat r -> Restrict (PlaceHolders p))
-> QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Delete p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) (PlaceHolders p)
-> Record Flat r -> Restrict (PlaceHolders p)
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 :: QueryA Restrict (Record Flat r) () -> Delete ()
deleteNoPH = (Record Flat r -> Restrict ()) -> Delete ()
forall r.
TableDerivable r =>
(Record Flat r -> Restrict ()) -> Delete ()
Monadic.deleteNoPH ((Record Flat r -> Restrict ()) -> Delete ())
-> (QueryA Restrict (Record Flat r) ()
    -> Record Flat r -> Restrict ())
-> QueryA Restrict (Record Flat r) ()
-> Delete ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryA Restrict (Record Flat r) () -> Record Flat r -> Restrict ()
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' :: Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
derivedUpdate' = Config
-> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
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 :: QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
derivedUpdate = QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p)
-> Update p
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' :: Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' = Config -> Register r (PlaceHolders p) -> Insert p
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 :: Register r (PlaceHolders p) -> Insert p
derivedInsertValue = Register r (PlaceHolders p) -> Insert p
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' :: Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete' = Config
-> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
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 :: QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
derivedDelete = QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
forall r p.
TableDerivable r =>
QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
delete