-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Typeful, Modular, Relational, algebraic query engine
--   
--   This package contiains typeful relation structure and
--   relational-algebraic query building DSL which can translate into SQL
--   query. Supported query features are below: - Type safe query building
--   - Restriction, Join, Aggregation - Modularized relations - Typed
--   placeholders
@package relational-query
@version 0.11.0.0


-- | This module provides untyped components for query.
module Database.Relational.Config

-- | <a>NameConfig</a> type to customize names of expanded templates.
data NameConfig
NameConfig :: NameConfig -> (String -> String -> VarName) -> NameConfig
[recordConfig] :: NameConfig -> NameConfig
[relationVarName] :: NameConfig -> String -> String -> VarName

-- | Unit of product is supported or not.
data ProductUnitSupport
PUSupported :: ProductUnitSupport
PUNotSupported :: ProductUnitSupport

-- | Schema name qualify mode in SQL string.
data SchemaNameMode

-- | Schema qualified table name in SQL string
SchemaQualified :: SchemaNameMode

-- | Not qualified table name in SQL string
SchemaNotQualified :: SchemaNameMode

-- | Configuration for quotation of identifiers of SQL.
data IdentifierQuotation
NoQuotation :: IdentifierQuotation
Quotation :: Char -> IdentifierQuotation

-- | Configuration type.
data Config

-- | Default configuration.
defaultConfig :: Config


-- | This module re-export query context tag types.
module Database.Relational.Context

-- | Type tag for flat (not-aggregated) query
data Flat

-- | Type tag for aggregated query
data Aggregated

-- | Type tag for exists predicate
data Exists

-- | Type tag for window function building
data OverWindow

-- | Type tag for normal aggregatings set
data Set

-- | Type tag for aggregatings GROUPING SETS
data SetList

-- | Type tag for aggregatings power set
data Power


-- | This module defines monad transformer which requires query generate
--   configuration.
module Database.Relational.Monad.Trans.Config

-- | <a>ReaderT</a> type to require query generate configuration.
data QueryConfig m a

-- | Lift to <a>QueryConfig</a>.
queryConfig :: Monad m => m a -> QueryConfig m a

-- | Run <a>QueryConfig</a> to expand with configuration
runQueryConfig :: QueryConfig m a -> Config -> m a

-- | Read configuration.
askQueryConfig :: Monad m => QueryConfig m Config
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Config.QueryConfig m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Config.QueryConfig m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Config.QueryConfig m)


-- | This module defines typed projection path objects. Contains internal
--   structure and unsafe interfaces.
module Database.Relational.Pi.Unsafe

-- | Projection path from type <tt>r0</tt> into type <tt>r1</tt>. This type
--   also indicate key object which type is <tt>r1</tt> for record type
--   <tt>r0</tt>.
data Pi r0 r1

-- | Get record width proof object.
width' :: PersistableWidth r => Pi r ct -> PersistableRecordWidth ct

-- | Get record width.
width :: PersistableWidth r => Pi r a -> Int

-- | Compose projection path.
(<.>) :: Pi a b -> Pi b c -> Pi a c
infixl 8 <.>

-- | Compose projection path. <a>Maybe</a> phantom functor is
--   <a>map</a>-ed.
(<?.>) :: Pi a (Maybe b) -> Pi b c -> Pi a (Maybe c)
infixl 8 <?.>

-- | Compose projection path. <a>Maybe</a> phantom functors are
--   <tt>join</tt>-ed like <tt>&gt;=&gt;</tt>.
(<?.?>) :: Pi a (Maybe b) -> Pi b (Maybe c) -> Pi a (Maybe c)
infixl 8 <?.?>

-- | Unsafely project untyped value list.
pi :: PersistableRecordWidth r0 -> Pi r0 r1 -> [a] -> [a]

-- | Unsafely define projection path from type <tt>r0</tt> into type
--   <tt>r1</tt>. Use inferred <a>PersistableRecordWidth</a>.
definePi :: PersistableWidth r1 => Int -> Pi r0 r1

-- | Unsafely define projection path from type <tt>r0</tt> into type
--   <tt>r1</tt>.
defineDirectPi' :: PersistableRecordWidth r1 -> [Int] -> Pi r0 r1

-- | Unsafely define projection path from type <tt>r0</tt> into type
--   <tt>r1</tt>. Use inferred <a>PersistableRecordWidth</a>.
defineDirectPi :: PersistableWidth r1 => [Int] -> Pi r0 r1

-- | Unsafely expand indexes from key.
unsafeExpandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]

-- | Unsafely expand indexes from key. Infered width version.
unsafeExpandIndexes :: PersistableWidth a => Pi a b -> [Int]
instance Database.Record.Persistable.PersistableWidth r0 => GHC.Show.Show (Database.Relational.Pi.Unsafe.Pi r0 r1)
instance Data.Functor.ProductIsomorphic.Class.ProductIsoFunctor (Database.Relational.Pi.Unsafe.Pi a)
instance Data.Functor.ProductIsomorphic.Class.ProductIsoApplicative (Database.Relational.Pi.Unsafe.Pi a)
instance Data.Functor.ProductIsomorphic.Class.ProductIsoEmpty (Database.Relational.Pi.Unsafe.Pi a) ()
instance Control.Category.Category Database.Relational.Pi.Unsafe.Pi


-- | This module defines typed projection path objects. Contains normal
--   interfaces.
module Database.Relational.Pi

-- | Projection path from type <tt>r0</tt> into type <tt>r1</tt>. This type
--   also indicate key object which type is <tt>r1</tt> for record type
--   <tt>r0</tt>.
data Pi r0 r1

-- | Compose projection path.
(<.>) :: Pi a b -> Pi b c -> Pi a c
infixl 8 <.>

-- | Compose projection path. <a>Maybe</a> phantom functor is
--   <a>map</a>-ed.
(<?.>) :: Pi a (Maybe b) -> Pi b c -> Pi a (Maybe c)
infixl 8 <?.>

-- | Compose projection path. <a>Maybe</a> phantom functors are
--   <tt>join</tt>-ed like <tt>&gt;=&gt;</tt>.
(<?.?>) :: Pi a (Maybe b) -> Pi b (Maybe c) -> Pi a (Maybe c)
infixl 8 <?.?>

-- | Identity projection path.
id' :: Pi a a


-- | This module provides proof object definitions of constraint key.
--   Difference between this module and
--   <a>Database.Record.KeyConstraint</a> is typed constraint key column
--   definition is included in this module.
module Database.Relational.Constraint

-- | Constraint Key proof object. Constraint type <tt>c</tt>, record type
--   <tt>r</tt> and columns type <tt>ct</tt>.
data Key c r ct

-- | Index of key which specifies constraint key.
indexes :: Key c r ct -> [Int]

-- | Unsafely generate constraint <a>Key</a> proof object using specified
--   key index.
unsafeDefineConstraintKey :: PersistableWidth ct => [Int] -> Key c r ct

-- | Get table constraint <a>KeyConstraint</a> proof object from constraint
--   <a>Key</a>.
tableConstraint :: Key c r ct -> KeyConstraint c r

-- | Get projection path proof object from constraint <a>Key</a>.
projectionKey :: Key c r ct -> Pi r ct

-- | Derive <a>Unique</a> constraint <a>Key</a> from <a>Primary</a>
--   constraint <a>Key</a>
uniqueKey :: PersistableWidth ct => Key Primary r ct -> Key Unique r ct

-- | Constraint <a>Key</a> inference interface.
class PersistableWidth ct => HasConstraintKey c r ct

-- | Infer constraint key.
constraintKey :: HasConstraintKey c r ct => Key c r ct

-- | Inferred <a>Unique</a> constraint <a>Key</a>. Record type <tt>r</tt>
--   has unique key which type is <tt>ct</tt> derived from primay key.
derivedUniqueKey :: HasConstraintKey Primary r ct => Key Unique r ct

-- | Constraint type. Primary key.
data Primary :: *

-- | Constraint type. Unique key.
data Unique :: *

-- | Constraint type. Not-null key.
data NotNull :: *


-- | This module provides interfaces to preserve constraints of direct
--   product projections.
module Database.Relational.ProjectableClass

-- | <a>ShowConstantTermsSQL</a> <tt>a</tt> is implicit rule to derive
--   function to convert from haskell record type <tt>a</tt> into constant
--   SQL terms.
--   
--   Generic programming
--   (<a>https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming</a>)
--   with default signature is available for <a>ShowConstantTermsSQL</a>
--   class, so you can make instance like below:
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   import GHC.Generics (Generic)
--   --
--   data Foo = Foo { ... } deriving Generic
--   instance ShowConstantTermsSQL Foo
--   </pre>
class ShowConstantTermsSQL a
showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL
showConstantTermsSQL' :: (ShowConstantTermsSQL a, Generic a, GShowConstantTermsSQL (Rep a)) => a -> DList StringSQL

-- | Convert from haskell record to SQL terms list.
showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL]

-- | String wrap type for SQL strings.
type StringSQL = Keyword
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL a => Database.Relational.ProjectableClass.GShowConstantTermsSQL (GHC.Generics.K1 i a)
instance Database.Relational.ProjectableClass.GShowConstantTermsSQL GHC.Generics.U1
instance (Database.Relational.ProjectableClass.GShowConstantTermsSQL a, Database.Relational.ProjectableClass.GShowConstantTermsSQL b) => Database.Relational.ProjectableClass.GShowConstantTermsSQL (a GHC.Generics.:*: b)
instance Database.Relational.ProjectableClass.GShowConstantTermsSQL a => Database.Relational.ProjectableClass.GShowConstantTermsSQL (GHC.Generics.M1 i c a)


-- | This module defines interfaces between haskell pure values and query
--   internal record values.
module Database.Relational.Pure
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL ()
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Int.Int8
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Int.Int16
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Int.Int32
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Int.Int64
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Types.Int
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Base.String
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.ByteString.Internal.ByteString
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.ByteString.Lazy.Internal.ByteString
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Text.Internal.Text
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Text.Internal.Lazy.Text
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Types.Char
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Types.Bool
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Types.Float
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL GHC.Types.Double
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Time.Calendar.Days.Day
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Time.LocalTime.Internal.LocalTime.LocalTime
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Time.LocalTime.Internal.ZonedTime.ZonedTime
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Data.Time.Clock.Internal.UTCTime.UTCTime
instance (Database.Record.Persistable.PersistableWidth a, Database.Relational.ProjectableClass.ShowConstantTermsSQL a) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (GHC.Base.Maybe a)


-- | This module defines type classes and templates for scalar queries.
module Database.Relational.Scalar

-- | Constraint which represents scalar degree.
class PersistableWidth ct => ScalarDegree ct

-- | <a>ScalarDegree</a> instance templates.
defineScalarDegree :: TypeQ -> Q [Dec]
instance Database.Relational.Scalar.ScalarDegree ct => Database.Relational.Scalar.ScalarDegree (GHC.Base.Maybe ct)


-- | This module is integrated module of sql-syntax.
module Database.Relational.SqlSyntax

-- | Sub-query type
data SubQuery
Table :: Untyped -> SubQuery
Flat :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [OrderingTerm] -> SubQuery
Aggregated :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [AggregateElem] -> [Predicate Aggregated] -> [OrderingTerm] -> SubQuery
Bin :: BinOp -> SubQuery -> SubQuery -> SubQuery

-- | Result record duplication attribute
data Duplication
All :: Duplication
Distinct :: Duplication

-- | Set operators
data SetOp
Union :: SetOp
Except :: SetOp
Intersect :: SetOp

-- | Set binary operators
newtype BinOp
BinOp :: (SetOp, Duplication) -> BinOp

-- | Qualifier type.
newtype Qualifier
Qualifier :: Int -> Qualifier

-- | Qualified query.
data Qualified a
Qualified :: Qualifier -> a -> Qualified a

-- | Get qualifier
qualifier :: Qualified a -> Qualifier

-- | Unqualify.
unQualify :: Qualified a -> a

-- | Add qualifier
qualify :: Qualifier -> a -> Qualified a

-- | Order direction. Ascendant or Descendant.
data Order
Asc :: Order
Desc :: Order

-- | Order of null.
data Nulls
NullsFirst :: Nulls
NullsLast :: Nulls

-- | Type for order-by column
type OrderColumn = StringSQL

-- | Type for order-by term
type OrderingTerm = ((Order, Maybe Nulls), OrderColumn)

-- | Type for group-by term
type AggregateColumnRef = StringSQL

-- | Type for group key.
newtype AggregateBitKey
AggregateBitKey :: [AggregateColumnRef] -> AggregateBitKey

-- | Type for grouping set
newtype AggregateSet
AggregateSet :: [AggregateElem] -> AggregateSet

-- | Type for group-by tree
data AggregateElem
ColumnRef :: AggregateColumnRef -> AggregateElem
Rollup :: [AggregateBitKey] -> AggregateElem
Cube :: [AggregateBitKey] -> AggregateElem
GroupingSets :: [AggregateSet] -> AggregateElem

-- | Typeful aggregate element.
newtype AggregateKey a
AggregateKey :: (a, AggregateElem) -> AggregateKey a

-- | node attribute for product.
data NodeAttr
Just' :: NodeAttr
Maybe :: NodeAttr

-- | Product tree type. Product tree is constructed by left node and right
--   node.
data ProductTree rs
Leaf :: QS -> ProductTree rs
Join :: !(Node rs) -> !(Node rs) -> !rs -> ProductTree rs

-- | Product node. node attribute and product tree.
data Node rs
Node :: !NodeAttr -> !(ProductTree rs) -> Node rs

-- | Get node attribute.
nodeAttr :: Node rs -> NodeAttr

-- | Get tree from node.
nodeTree :: Node rs -> ProductTree rs

-- | Type for join product of query.
type JoinProduct = Maybe (ProductTree [Predicate Flat])

-- | case clause
data CaseClause
CaseSearch :: WhenClauses -> CaseClause
CaseSimple :: Tuple -> WhenClauses -> CaseClause

-- | when clauses
data WhenClauses
WhenClauses :: [(Tuple, Tuple)] -> Tuple -> WhenClauses

-- | Projected column structure unit with single column width
data Column

-- | used in immediate value or unsafe operations
RawColumn :: StringSQL -> Column

-- | normalized sub-query reference T<a>n</a> with Int index
SubQueryRef :: (Qualified Int) -> Column

-- | scalar sub-query
Scalar :: SubQuery -> Column

-- | <a>n</a>th column of case clause
Case :: CaseClause -> Int -> Column

-- | Untyped projected tuple. Forgot record type.
type Tuple = [Column]

-- | Width of <a>Tuple</a>.
tupleWidth :: Tuple -> Int

-- | Phantom typed record. Projected into Haskell record type <tt>t</tt>.
data Record c t

-- | Discard record type
untypeRecord :: Record c t -> Tuple

-- | Unsafely type <a>Tuple</a> value to <a>Record</a> type.
record :: Tuple -> Record c t

-- | Type for projection function.
type PI c a b = Record c a -> Record c b

-- | Width of <a>Record</a>.
recordWidth :: Record c r -> Int

-- | Unsafely generate <a>Record</a> from SQL string list.
typeFromRawColumns :: [StringSQL] -> Record c r

-- | Unsafely generate <a>Record</a> from scalar sub-query.
typeFromScalarSubQuery :: SubQuery -> Record c t

-- | Type for predicate to restrict of query result.
type Predicate c = Record c (Maybe Bool)

-- | Push new leaf node into product right term.
growProduct :: Maybe (Node (DList (Predicate Flat))) -> (NodeAttr, Qualified SubQuery) -> Node (DList (Predicate Flat))

-- | Add restriction into top product of product tree node.
restrictProduct :: Node (DList (Predicate Flat)) -> Predicate Flat -> Node (DList (Predicate Flat))

-- | Single term aggregation element.
aggregateColumnRef :: AggregateColumnRef -> AggregateElem

-- | Key of aggregation power set.
aggregatePowerKey :: [AggregateColumnRef] -> AggregateBitKey

-- | Single grouping set.
aggregateGroupingSet :: [AggregateElem] -> AggregateSet

-- | Rollup aggregation element.
aggregateRollup :: [AggregateBitKey] -> AggregateElem

-- | Cube aggregation element.
aggregateCube :: [AggregateBitKey] -> AggregateElem

-- | Grouping sets aggregation.
aggregateSets :: [AggregateSet] -> AggregateElem

-- | Compose GROUP BY clause from AggregateElem list.
composeGroupBy :: [AggregateElem] -> StringSQL

-- | Compose PARTITION BY clause from AggregateColumnRef list.
composePartitionBy :: [AggregateColumnRef] -> StringSQL

-- | Extract typed record from <a>AggregateKey</a>.
aggregateKeyRecord :: AggregateKey a -> a

-- | Extract untyped term from <a>AggregateKey</a>.
aggregateKeyElement :: AggregateKey a -> AggregateElem

-- | Unsafely bind typed-record and untyped-term into <a>AggregateKey</a>.
unsafeAggregateKey :: (a, AggregateElem) -> AggregateKey a

-- | Unsafely generate flat <a>SubQuery</a> from untyped components.
flatSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [OrderingTerm] -> SubQuery

-- | Unsafely generate aggregated <a>SubQuery</a> from untyped components.
aggregatedSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [AggregateElem] -> [Predicate Aggregated] -> [OrderingTerm] -> SubQuery

-- | Union binary operator on <a>SubQuery</a>
union :: Duplication -> SubQuery -> SubQuery -> SubQuery

-- | Except binary operator on <a>SubQuery</a>
except :: Duplication -> SubQuery -> SubQuery -> SubQuery

-- | Intersect binary operator on <a>SubQuery</a>
intersect :: Duplication -> SubQuery -> SubQuery -> SubQuery

-- | Search case operator correnponding SQL search <i>CASE</i>. Like,
--   <i>CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END</i>
caseSearch :: [(Predicate c, Record c a)] -> Record c a -> Record c a

-- | Simple case operator correnponding SQL simple <i>CASE</i>. Like,
--   <i>CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END</i>
case' :: Record c a -> [(Record c a, Record c b)] -> Record c b -> Record c b

-- | Compose ORDER BY clause from OrderingTerms
composeOrderBy :: [OrderingTerm] -> StringSQL

-- | SQL StringSQL for toplevel-SQL.
showSQL :: SubQuery -> StringSQL

-- | SQL string for toplevel-SQL.
toSQL :: SubQuery -> String

-- | SQL string for nested-qeury.
unitSQL :: SubQuery -> String

-- | Width of <a>SubQuery</a>.
width :: SubQuery -> Int

-- | Width of <a>Qualified</a> <tt>SubQUery</tt>.
queryWidth :: Qualified SubQuery -> Int

-- | Get column SQL string of <a>Qualified</a> <a>SubQuery</a>.
column :: Qualified SubQuery -> Int -> StringSQL

-- | Make untyped tuple (qualified column list) from joined sub-query
--   (<a>Qualified</a> <a>SubQuery</a>).
tupleFromJoinedSubQuery :: Qualified SubQuery -> Tuple

-- | Get column SQL string list of record.
recordRawColumns :: Record c r -> [StringSQL]

-- | Compose WHERE clause from <tt>QueryRestriction</tt>.
composeWhere :: [Predicate Flat] -> StringSQL

-- | Compose HAVING clause from <tt>QueryRestriction</tt>.
composeHaving :: [Predicate Aggregated] -> StringSQL

-- | Column SQL String of assignment
type AssignColumn = StringSQL

-- | Value SQL String of assignment
type AssignTerm = StringSQL

-- | Assignment pair
type Assignment = (AssignColumn, AssignTerm)

-- | Compose SET clause from [<a>Assignment</a>].
composeSets :: [Assignment] -> StringSQL

-- | Compose VALUES clause from value expression list.
composeChunkValues :: Int -> [AssignTerm] -> Keyword

-- | Compose VALUES clause from value expression list.
composeChunkValuesWithColumns :: Int -> [Assignment] -> StringSQL


-- | This module provides unsafe interfaces between projected terms and SQL
--   terms.
module Database.Relational.Projectable.Unsafe

-- | Interface to project SQL terms unsafely.
class SqlContext c

-- | Unsafely project from SQL expression terms.
unsafeProjectSqlTerms :: SqlContext c => [StringSQL] -> Record c t

-- | Constraint to restrict context of full SQL expressions. For example,
--   the expression at the left of OVER clause is not allowed using full
--   SQL expression.
class SqlContext c => OperatorContext c

-- | Constraint to restrict context of aggregated SQL context.
class AggregatedContext ac

-- | Placeholder parameter type which has real parameter type arguemnt
--   <tt>p</tt>.
data PlaceHolders p
PlaceHolders :: PlaceHolders p


-- | This module defines base monad type to build queries.
module Database.Relational.Monad.BaseType

-- | Thin monad type for untyped structure.
type ConfigureQuery = Qualify (QueryConfig Identity)

-- | Run <a>ConfigureQuery</a> monad with initial state to get only result.
configureQuery :: ConfigureQuery q -> Config -> q

-- | Get qualifyed table form query.
qualifyQuery :: a -> ConfigureQuery (Qualified a)

-- | Read configuration.
askConfig :: ConfigureQuery Config

-- | Relation type with place-holder parameter <tt>p</tt> and query result
--   type <tt>r</tt>.
data Relation p r

-- | Unsafely type qualified subquery into record typed relation type.
unsafeTypeRelation :: ConfigureQuery SubQuery -> Relation p r

-- | Sub-query Qualify monad from relation.
untypeRelation :: Relation p r -> ConfigureQuery SubQuery

-- | <a>PersistableRecordWidth</a> of <a>Relation</a> type.
relationWidth :: Relation p r -> PersistableRecordWidth r

-- | Dump internal structure tree.
dump :: Relation p r -> String

-- | Generate SQL string from <a>Relation</a> with configuration.
sqlFromRelationWith :: Relation p r -> Config -> StringSQL

-- | SQL string from <a>Relation</a>.
sqlFromRelation :: Relation p r -> StringSQL

-- | Simplify placeholder type applying left identity element.
rightPh :: Relation ((), p) r -> Relation p r

-- | Simplify placeholder type applying right identity element.
leftPh :: Relation (p, ()) r -> Relation p r
instance GHC.Show.Show (Database.Relational.Monad.BaseType.Relation p r)


-- | This module defines table type which has table metadatas.
module Database.Relational.Table

-- | Phantom typed table type
data Table r

-- | Untype table.
untype :: Table t -> Untyped

-- | Name string of table in SQL
name :: Table r -> String

-- | Not qualified name string of table in SQL
shortName :: Table r -> String

-- | Width of table
width :: Table r -> Int

-- | Column name strings in SQL
columns :: Table r -> [StringSQL]

-- | Column name string in SQL specified by index
index :: Table r -> Int -> StringSQL

-- | Unsafely generate phantom typed table type.
table :: String -> [String] -> Table r

-- | Cast phantom type into <a>Maybe</a> type.
toMaybe :: Table r -> Table (Maybe r)

-- | PersistableRecordWidth of table
recordWidth :: Table r -> PersistableRecordWidth r

-- | Deprecated. use <a>untype</a>.

-- | <i>Deprecated: Use untype instead of this.</i>
unType :: Table t -> Untyped

-- | <a>SubQuery</a> from <a>Table</a>.
toSubQuery :: Table r -> SubQuery

-- | Inference rule of <a>Table</a> existence.
class PersistableWidth r => TableDerivable r
derivedTable :: TableDerivable r => Table r


-- | This module defines interfaces of projected record type.
module Database.Relational.Record

-- | Phantom typed record. Projected into Haskell record type <tt>t</tt>.
data Record c t

-- | Width of <a>Record</a>.
width :: Record c r -> Int

-- | Get column SQL string list of record.
columns :: Record c r -> [StringSQL]

-- | Get untyped tuple.
untype :: Record c r -> Tuple

-- | Unsafely generate <a>Record</a> from SQL expression strings.
unsafeFromSqlTerms :: [StringSQL] -> Record c t

-- | Unsafely generate <a>Record</a> from qualified (joined) sub-query.
unsafeFromQualifiedSubQuery :: Qualified SubQuery -> Record c t

-- | Unsafely generate <a>Record</a> from scalar sub-query.
unsafeFromScalarSubQuery :: SubQuery -> Record c t

-- | Unsafely generate unqualified <a>Record</a> from <a>Table</a>.
unsafeFromTable :: Table r -> Record c r

-- | Unsafely get SQL term from <a>Record</a>.
unsafeStringSql :: Record c r -> StringSQL

-- | Trace projection path to get narrower <a>Record</a>.
pi :: PersistableWidth a => Record c a -> Pi a b -> Record c b

-- | Trace projection path to get narrower <a>Record</a>. From <a>Maybe</a>
--   type to <a>Maybe</a> type.
piMaybe :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)

-- | Trace projection path to get narrower <a>Record</a>. From <a>Maybe</a>
--   type to <a>Maybe</a> type. Leaf type of projection path is
--   <a>Maybe</a>.
piMaybe' :: PersistableWidth a => Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)

-- | Trace projection path to get narrower <a>Record</a>.
wpi :: PersistableRecordWidth a -> Record c a -> Pi a b -> Record c b

-- | Composite nested <a>Maybe</a> on record phantom type.
flattenMaybe :: Record c (Maybe (Maybe a)) -> Record c (Maybe a)

-- | Cast into <a>Maybe</a> on record phantom type.
just :: Record c r -> Record c (Maybe r)

-- | Unsafely lift to aggregated context.
unsafeToAggregated :: Record Flat r -> Record Aggregated r

-- | Unsafely down to flat context.
unsafeToFlat :: Record Aggregated r -> Record Flat r

-- | Unsafely cast context type tag.
unsafeChangeContext :: Record c r -> Record c' r

-- | Unsafely get SQL string expression of not null key record.
unsafeStringSqlNotNullMaybe :: HasColumnConstraint NotNull r => Record c (Maybe r) -> StringSQL

-- | Projected record list type for row list.
data RecordList p t

-- | Make projected record list from <a>Record</a> list.
list :: [p t] -> RecordList p t

-- | Make projected record list from <a>SubQuery</a>.
unsafeListFromSubQuery :: SubQuery -> RecordList p t

-- | Map record show operatoions and concatinate to single SQL expression.
unsafeStringSqlList :: (p t -> StringSQL) -> RecordList p t -> StringSQL
instance Data.Functor.ProductIsomorphic.Class.ProductIsoFunctor (Database.Relational.SqlSyntax.Types.Record c)
instance Data.Functor.ProductIsomorphic.Class.ProductIsoApplicative (Database.Relational.SqlSyntax.Types.Record c)
instance Data.Functor.ProductIsomorphic.Class.ProductIsoEmpty (Database.Relational.SqlSyntax.Types.Record c) ()


-- | This module defines functions to generate simple SQL strings.
module Database.Relational.SimpleSql

-- | Type for query suffix words
type QuerySuffix = [Keyword]

-- | Expand query suffix words
showsQuerySuffix :: QuerySuffix -> StringSQL

-- | Generate prefix string of update SQL.
updatePrefixSQL :: Table r -> StringSQL

-- | Generate update SQL specified by single key.
updateOtherThanKeySQL :: Table r -> Pi r p -> String

-- | Generate prefix string of insert SQL.
insertPrefixSQL :: Pi r r' -> Table r -> StringSQL

-- | Generate all column delete SQL by specified table.
deletePrefixSQL :: Table r -> StringSQL


-- | This module provides instances between projected terms and SQL terms.
module Database.Relational.Projectable.Instances
instance Database.Relational.Projectable.Unsafe.SqlContext Database.Relational.Internal.ContextType.Flat
instance Database.Relational.Projectable.Unsafe.SqlContext Database.Relational.Internal.ContextType.Aggregated
instance Database.Relational.Projectable.Unsafe.SqlContext Database.Relational.Internal.ContextType.OverWindow
instance Database.Relational.Projectable.Unsafe.OperatorContext Database.Relational.Internal.ContextType.Flat
instance Database.Relational.Projectable.Unsafe.OperatorContext Database.Relational.Internal.ContextType.Aggregated
instance Database.Relational.Projectable.Unsafe.AggregatedContext Database.Relational.Internal.ContextType.Aggregated
instance Database.Relational.Projectable.Unsafe.AggregatedContext Database.Relational.Internal.ContextType.OverWindow
instance Data.Functor.ProductIsomorphic.Class.ProductIsoEmpty Database.Relational.Projectable.Unsafe.PlaceHolders ()
instance Data.Functor.ProductIsomorphic.Class.ProductIsoFunctor Database.Relational.Projectable.Unsafe.PlaceHolders
instance Data.Functor.ProductIsomorphic.Class.ProductIsoApplicative Database.Relational.Projectable.Unsafe.PlaceHolders


-- | This module defines ProductConstructor instances and projection path
--   objects of tuple types.
module Database.Relational.TupleInstances
tuplePi7_6' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a7
tuplePi7_5' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a6
tuplePi7_4' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a5
tuplePi7_3' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a4
tuplePi7_2' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a3
tuplePi7_1' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a2
tuplePi7_0' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a1
tuplePi6_5' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a6
tuplePi6_4' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a5
tuplePi6_3' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a4
tuplePi6_2' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a3
tuplePi6_1' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a2
tuplePi6_0' :: forall a1 a2 a3 a4 a5 a6. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a1
tuplePi5_4' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a5
tuplePi5_3' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a4
tuplePi5_2' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a3
tuplePi5_1' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a2
tuplePi5_0' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a1
tuplePi4_3' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a4
tuplePi4_2' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a3
tuplePi4_1' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a2
tuplePi4_0' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a1
tuplePi3_2' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a3
tuplePi3_1' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a2
tuplePi3_0' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a1
tuplePi2_1' :: forall a1 a2. (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a2
tuplePi2_0' :: forall a1 a2. (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a1

-- | Projection path for fst of tuple.
fst' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) a

-- | Projection path for snd of tuple.
snd' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) b
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2)
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2, Database.Relational.ProjectableClass.ShowConstantTermsSQL a3) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2, a3)
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2, Database.Relational.ProjectableClass.ShowConstantTermsSQL a3, Database.Relational.ProjectableClass.ShowConstantTermsSQL a4) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2, a3, a4)
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2, Database.Relational.ProjectableClass.ShowConstantTermsSQL a3, Database.Relational.ProjectableClass.ShowConstantTermsSQL a4, Database.Relational.ProjectableClass.ShowConstantTermsSQL a5) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2, a3, a4, a5)
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2, Database.Relational.ProjectableClass.ShowConstantTermsSQL a3, Database.Relational.ProjectableClass.ShowConstantTermsSQL a4, Database.Relational.ProjectableClass.ShowConstantTermsSQL a5, Database.Relational.ProjectableClass.ShowConstantTermsSQL a6) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2, a3, a4, a5, a6)
instance (Database.Relational.ProjectableClass.ShowConstantTermsSQL a1, Database.Relational.ProjectableClass.ShowConstantTermsSQL a2, Database.Relational.ProjectableClass.ShowConstantTermsSQL a3, Database.Relational.ProjectableClass.ShowConstantTermsSQL a4, Database.Relational.ProjectableClass.ShowConstantTermsSQL a5, Database.Relational.ProjectableClass.ShowConstantTermsSQL a6, Database.Relational.ProjectableClass.ShowConstantTermsSQL a7) => Database.Relational.ProjectableClass.ShowConstantTermsSQL (a1, a2, a3, a4, a5, a6, a7)


-- | This module defines operators on various projected records.
module Database.Relational.Projectable

-- | Interface to project SQL terms unsafely.
class SqlContext c

-- | Unsafely project from SQL expression terms.
unsafeProjectSqlTerms :: SqlContext c => [StringSQL] -> Record c t

-- | Unsafely Project single SQL term.
unsafeProjectSql' :: SqlContext c => StringSQL -> Record c t

-- | Unsafely Project single SQL string. String interface of
--   <tt>unsafeProjectSql''</tt>.
unsafeProjectSql :: SqlContext c => String -> Record c t

-- | Generate record with polymorphic type of SQL constant values from
--   Haskell value.
value :: (ShowConstantTermsSQL t, OperatorContext c) => t -> Record c t

-- | Record with polymorphic type of SQL true value.
valueTrue :: (OperatorContext c, ProjectableMaybe (Record c)) => Record c (Maybe Bool)

-- | Record with polymorphic type of SQL false value.
valueFalse :: (OperatorContext c, ProjectableMaybe (Record c)) => Record c (Maybe Bool)

-- | RecordList with polymorphic type of SQL set value from Haskell list.
values :: (ShowConstantTermsSQL t, OperatorContext c) => [t] -> RecordList (Record c) t

-- | Record with polymorphic phantom type of SQL null value. Semantics of
--   comparing is unsafe.
nothing :: (OperatorContext c, SqlContext c, PersistableWidth a) => Record c (Maybe a)

-- | Placeholder parameter type which has real parameter type arguemnt
--   <tt>p</tt>.
data PlaceHolders p

-- | Unsafely add placeholder parameter to queries.
unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)

-- | Unsafely get placeholder parameter
unsafePlaceHolders :: PlaceHolders p

-- | Provide scoped placeholder from width and return its parameter object.
pwPlaceholder :: SqlContext c => PersistableRecordWidth a -> (Record c a -> b) -> (PlaceHolders a, b)

-- | Provide scoped placeholder and return its parameter object.
placeholder' :: (PersistableWidth t, SqlContext c) => (Record c t -> a) -> (PlaceHolders t, a)

-- | Provide scoped placeholder and return its parameter object. Monadic
--   version.
placeholder :: (PersistableWidth t, SqlContext c, Monad m) => (Record c t -> m a) -> m (PlaceHolders t, a)

-- | No placeholder semantics
unitPlaceHolder :: PlaceHolders ()

-- | No placeholder semantics. Same as <a>unitPlaceHolder</a>
unitPH :: PlaceHolders ()

-- | Unsafely generate SQL expression term from record object.
unsafeShowSql' :: Record c a -> StringSQL

-- | Unsafely generate SQL expression string from record object. String
--   interface of <a>unsafeShowSql'</a>.
unsafeShowSql :: Record c a -> String

-- | Compare operator corresponding SQL <i>=</i> .
(.=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .=.

-- | Compare operator corresponding SQL <i>&lt;</i> .
(.<.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .<.

-- | Compare operator corresponding SQL <i>&lt;=</i> .
(.<=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .<=.

-- | Compare operator corresponding SQL <i>&gt;</i> .
(.>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .>.

-- | Compare operator corresponding SQL <i>&gt;=</i> .
(.>=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .>=.

-- | Compare operator corresponding SQL <i>&lt;&gt;</i> .
(.<>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
infix 4 .<>.

-- | Logical operator corresponding SQL <i>AND</i> .
and' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
infixr 3 `and'`

-- | Logical operator corresponding SQL <i>OR</i> .
or' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
infixr 2 `or'`

-- | Binary operator corresponding SQL <i>IN</i> .
in' :: OperatorContext c => Record c t -> RecordList (Record c) t -> Record c (Maybe Bool)
infix 4 `in'`

-- | Concatinate operator corresponding SQL <i>||</i> .
(.||.) :: OperatorContext c => Record c a -> Record c a -> Record c a
infixl 5 .||.

-- | Concatinate operator corresponding SQL <i>||</i> . Maybe type version.
(?||?) :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
infixl 5 ?||?

-- | String-compare operator corresponding SQL <i>LIKE</i> .
like :: (OperatorContext c, IsString a, ShowConstantTermsSQL a) => Record c a -> a -> Record c (Maybe Bool)
infix 4 `like`

-- | String-compare operator corresponding SQL <i>LIKE</i> . Maybe type
--   version.
likeMaybe :: (OperatorContext c, IsString a, ShowConstantTermsSQL a) => Record c (Maybe a) -> a -> Record c (Maybe Bool)
infix 4 `likeMaybe`

-- | String-compare operator corresponding SQL <i>LIKE</i> .
like' :: (OperatorContext c, IsString a) => Record c a -> Record c a -> Record c (Maybe Bool)
infix 4 `like'`

-- | String-compare operator corresponding SQL <i>LIKE</i> .
likeMaybe' :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe Bool)
infix 4 `likeMaybe'`

-- | Number operator corresponding SQL <i>+</i> .
(.+.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
infixl 6 .+.

-- | Number operator corresponding SQL <i>-</i> .
(.-.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
infixl 6 .-.

-- | Number operator corresponding SQL <i>*</i> .
(.*.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
infixl 7 .*.

-- | Number operator corresponding SQL /// .
(./.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
infixl 7 ./.

-- | Number operator corresponding SQL <i>+</i> .
(?+?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
infixl 6 ?+?

-- | Number operator corresponding SQL <i>-</i> .
(?-?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
infixl 6 ?-?

-- | Number operator corresponding SQL <i>*</i> .
(?*?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
infixl 7 ?*?

-- | Number operator corresponding SQL /// .
(?/?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
infixl 7 ?/?

-- | Operator corresponding SQL <i>IS NULL</i> , and extended against
--   record types.
isNothing :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c

-- | Operator corresponding SQL <i>NOT (... IS NULL)</i> , and extended
--   against record type.
isJust :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c

-- | Operator from maybe type using record extended <tt>isNull</tt>.
fromMaybe :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c r -> Record c (Maybe r) -> Record c r

-- | Logical operator corresponding SQL <i>NOT</i> .
not' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool)

-- | Logical operator corresponding SQL <i>EXISTS</i> .
exists :: OperatorContext c => RecordList (Record Exists) r -> Record c (Maybe Bool)

-- | Number negate uni-operator corresponding SQL <i>-</i>.
negate' :: (OperatorContext c, Num a) => Record c a -> Record c a

-- | Number fromIntegral uni-operator.
fromIntegral' :: (SqlContext c, Integral a, Num b) => Record c a -> Record c b

-- | Unsafely show number into string-like type in records.
showNum :: (SqlContext c, Num a, IsString b) => Record c a -> Record c b

-- | Number negate uni-operator corresponding SQL <i>-</i>.
negateMaybe :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a)

-- | Number fromIntegral uni-operator.
fromIntegralMaybe :: (SqlContext c, Integral a, Num b) => Record c (Maybe a) -> Record c (Maybe b)

-- | Unsafely show number into string-like type in records.
showNumMaybe :: (SqlContext c, Num a, IsString b) => Record c (Maybe a) -> Record c (Maybe b)

-- | Same as <a>caseSearch</a>, but you can write like <a>list</a>
--   <a>casesOrElse</a> <a>clause</a>.
casesOrElse :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a

-- | Uncurry version of <a>case'</a>, and you can write like ...
--   <a>casesOrElse'</a> <a>clause</a>.
casesOrElse' :: OperatorContext c => (Record c a, [(Record c a, Record c b)]) -> Record c b -> Record c b

-- | Search case operator correnponding SQL search <i>CASE</i>. Like,
--   <i>CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END</i>
caseSearch :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a

-- | Null default version of <a>caseSearch</a>.
caseSearchMaybe :: (OperatorContext c, PersistableWidth a) => [(Predicate c, Record c (Maybe a))] -> Record c (Maybe a)

-- | Simple case operator correnponding SQL simple <i>CASE</i>. Like,
--   <i>CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END</i>
case' :: OperatorContext c => Record c a -> [(Record c a, Record c b)] -> Record c b -> Record c b

-- | Null default version of <a>case'</a>.
caseMaybe :: (OperatorContext c, PersistableWidth b) => Record c a -> [(Record c a, Record c (Maybe b))] -> Record c (Maybe b)

-- | Binary operator type for SQL String.
type SqlBinOp = Keyword -> Keyword -> Keyword

-- | Unsafely make binary operator for records from string binary operator.
unsafeBinOp :: SqlContext k => SqlBinOp -> Record k a -> Record k b -> Record k c

-- | Unsafely make unary operator for records from SQL keyword.
unsafeUniOp :: SqlContext c2 => (Keyword -> Keyword) -> Record c1 a -> Record c2 b

-- | <i>RANK()</i> term.
rank :: Integral a => Record OverWindow a

-- | <i>DENSE_RANK()</i> term.
denseRank :: Integral a => Record OverWindow a

-- | <i>ROW_NUMBER()</i> term.
rowNumber :: Integral a => Record OverWindow a

-- | <i>PERCENT_RANK()</i> term.
percentRank :: Record OverWindow Double

-- | <i>CUME_DIST()</i> term.
cumeDist :: Record OverWindow Double

-- | Zipping projections.
projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)

-- | Binary operator the same as <a>projectZip</a>.
(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)
infixl 1 ><

-- | Interface to control <a>Maybe</a> of phantom type in records.
class ProjectableMaybe p

-- | Cast record phantom type into <a>Maybe</a>.
just :: ProjectableMaybe p => p a -> p (Maybe a)

-- | Compose nested <a>Maybe</a> phantom type on record.
flattenMaybe :: ProjectableMaybe p => p (Maybe (Maybe a)) -> p (Maybe a)

-- | Interface to compose phantom <a>Maybe</a> nested type.
class ProjectableFlattenMaybe a b
flatten :: (ProjectableFlattenMaybe a b, ProjectableMaybe p) => p a -> p b

-- | Get narrower record with flatten leaf phantom Maybe types along with
--   projection path.
flattenPiMaybe :: (PersistableWidth a, ProjectableMaybe (Record cont), ProjectableFlattenMaybe (Maybe b) c) => Record cont (Maybe a) -> Pi a b -> Record cont c

-- | Get narrower record along with projection path.
(!) :: PersistableWidth a => Record c a -> Pi a b -> Record c b
infixl 8 !

-- | Same as '(?!)'. Use this operator like '(? #foo) mayX'.
(?) :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
infixl 8 ?

-- | Same as '(?!?)'. Use this operator like '(?? #foo) mayX'.
(??) :: PersistableWidth a => Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
infixl 8 ??

-- | Get narrower record along with projection path <a>Maybe</a> phantom
--   functor is <a>map</a>-ed.
(?!) :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
infixl 8 ?!

-- | Get narrower record along with projection path and project into result
--   record type. Source record <a>Maybe</a> phantom functor and projection
--   path leaf <a>Maybe</a> functor are <tt>join</tt>-ed.
(?!?) :: PersistableWidth a => Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
infixl 8 ?!?

-- | Get narrower record with flatten leaf phantom Maybe types along with
--   projection path.
(!??) :: (PersistableWidth a, ProjectableMaybe (Record cont), ProjectableFlattenMaybe (Maybe b) c) => Record cont (Maybe a) -> Pi a b -> Record cont c
infixl 8 !??

-- | Unsafely make aggregation uni-operator from SQL keyword.
unsafeAggregateOp :: (AggregatedContext ac, SqlContext ac) => Keyword -> Record Flat a -> Record ac b

-- | Aggregation function COUNT.
count :: (Integral b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac b

-- | Aggregation function SUM.
sum' :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)

-- | Aggregation function SUM.
sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)

-- | Aggregation function AVG.
avg :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe b)

-- | Aggregation function AVG.
avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe b)

-- | Aggregation function MAX.
max' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)

-- | Aggregation function MAX.
maxMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)

-- | Aggregation function MIN.
min' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)

-- | Aggregation function MIN.
minMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)

-- | Aggregation function EVERY.
every :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)

-- | Aggregation function ANY.
any' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)

-- | Aggregation function SOME.
some' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)
instance Database.Relational.Projectable.ProjectableFlattenMaybe (GHC.Base.Maybe a) b => Database.Relational.Projectable.ProjectableFlattenMaybe (GHC.Base.Maybe (GHC.Base.Maybe a)) b
instance Database.Relational.Projectable.ProjectableFlattenMaybe (GHC.Base.Maybe a) (GHC.Base.Maybe a)
instance Database.Relational.Projectable.ProjectableMaybe Database.Relational.Projectable.Unsafe.PlaceHolders
instance Database.Relational.Projectable.ProjectableMaybe (Database.Relational.SqlSyntax.Types.Record c)


-- | This module provides interfaces of overloaded projections.
module Database.Relational.OverloadedProjection

-- | Projection interface to implement Pi with row polymorphism.
class HasProjection l a b | l a -> b
projection :: HasProjection l a b => PiLabel l -> Pi a b
instance Database.Relational.OverloadedProjection.HasProjection l a b => GHC.OverloadedLabels.IsLabel l (Database.Relational.Pi.Unsafe.Pi a b)
instance (Database.Record.Persistable.PersistableWidth a, Database.Relational.OverloadedProjection.HasProjection l a b) => GHC.OverloadedLabels.IsLabel l (Database.Relational.SqlSyntax.Types.PI c a b)


-- | This module provides basic instances of overloaded projections like
--   tuples..
module Database.Relational.OverloadedInstances
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2) => Database.Relational.OverloadedProjection.HasProjection "tuplePi2_0" (a1, a2) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2) => Database.Relational.OverloadedProjection.HasProjection "tuplePi2_1" (a1, a2) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "tuplePi3_0" (a1, a2, a3) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "tuplePi3_1" (a1, a2, a3) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "tuplePi3_2" (a1, a2, a3) a3
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4) => Database.Relational.OverloadedProjection.HasProjection "tuplePi4_0" (a1, a2, a3, a4) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4) => Database.Relational.OverloadedProjection.HasProjection "tuplePi4_1" (a1, a2, a3, a4) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4) => Database.Relational.OverloadedProjection.HasProjection "tuplePi4_2" (a1, a2, a3, a4) a3
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4) => Database.Relational.OverloadedProjection.HasProjection "tuplePi4_3" (a1, a2, a3, a4) a4
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5) => Database.Relational.OverloadedProjection.HasProjection "tuplePi5_0" (a1, a2, a3, a4, a5) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5) => Database.Relational.OverloadedProjection.HasProjection "tuplePi5_1" (a1, a2, a3, a4, a5) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5) => Database.Relational.OverloadedProjection.HasProjection "tuplePi5_2" (a1, a2, a3, a4, a5) a3
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5) => Database.Relational.OverloadedProjection.HasProjection "tuplePi5_3" (a1, a2, a3, a4, a5) a4
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5) => Database.Relational.OverloadedProjection.HasProjection "tuplePi5_4" (a1, a2, a3, a4, a5) a5
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_0" (a1, a2, a3, a4, a5, a6) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_1" (a1, a2, a3, a4, a5, a6) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_2" (a1, a2, a3, a4, a5, a6) a3
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_3" (a1, a2, a3, a4, a5, a6) a4
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_4" (a1, a2, a3, a4, a5, a6) a5
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6) => Database.Relational.OverloadedProjection.HasProjection "tuplePi6_5" (a1, a2, a3, a4, a5, a6) a6
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_0" (a1, a2, a3, a4, a5, a6, a7) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_1" (a1, a2, a3, a4, a5, a6, a7) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_2" (a1, a2, a3, a4, a5, a6, a7) a3
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_3" (a1, a2, a3, a4, a5, a6, a7) a4
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_4" (a1, a2, a3, a4, a5, a6, a7) a5
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_5" (a1, a2, a3, a4, a5, a6, a7) a6
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3, Database.Record.Persistable.PersistableWidth a4, Database.Record.Persistable.PersistableWidth a5, Database.Record.Persistable.PersistableWidth a6, Database.Record.Persistable.PersistableWidth a7) => Database.Relational.OverloadedProjection.HasProjection "tuplePi7_6" (a1, a2, a3, a4, a5, a6, a7) a7
instance Database.Record.Persistable.PersistableWidth a => Database.Relational.OverloadedProjection.HasProjection "fst" (a, b) a
instance (Database.Record.Persistable.PersistableWidth a, Database.Record.Persistable.PersistableWidth b) => Database.Relational.OverloadedProjection.HasProjection "snd" (a, b) b


-- | This module defines query building interface classes.
module Database.Relational.Monad.Class

-- | Lift interface from base qualify monad.
class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m

-- | Lift from qualify monad <tt>q</tt> into <a>MonadQuery</a> m. Qualify
--   monad qualifies table form <tt>SubQuery</tt>.
liftQualify :: MonadQualify q m => q a -> m a

-- | Restrict context interface
class (Functor m, Monad m) => MonadRestrict c m

-- | Add restriction to this context.
restrict :: MonadRestrict c m => Predicate c -> m ()

-- | Query building interface.
class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery m

-- | Specify duplication.
setDuplication :: MonadQuery m => Duplication -> m ()

-- | Add restriction to last join.
restrictJoin :: MonadQuery m => Predicate Flat -> m ()

-- | Join sub-query with place-holder parameter <tt>p</tt>. query result is
--   not <a>Maybe</a>.
query' :: MonadQuery m => Relation p r -> m (PlaceHolders p, Record Flat r)

-- | Join sub-query with place-holder parameter <tt>p</tt>. Query result is
--   <a>Maybe</a>.
queryMaybe' :: MonadQuery m => Relation p r -> m (PlaceHolders p, Record Flat (Maybe r))

-- | Aggregated query building interface extends <a>MonadQuery</a>.
class MonadQuery m => MonadAggregate m

-- | Add <i>GROUP BY</i> term into context and get aggregated record.
groupBy :: MonadAggregate m => Record Flat r -> m (Record Aggregated r)
groupBy' :: MonadAggregate m => AggregateKey (Record Aggregated r) -> m (Record Aggregated r)

-- | Window specification building interface.
class Monad m => MonadPartition c m

-- | Add <i>PARTITION BY</i> term into context.
partitionBy :: MonadPartition c m => Record c r -> m ()

-- | Specify ALL attribute to query context.
all' :: MonadQuery m => m ()

-- | Specify DISTINCT attribute to query context.
distinct :: MonadQuery m => m ()

-- | Add restriction to last join. Record type version.
on :: MonadQuery m => Predicate Flat -> m ()

-- | Add restriction to this not aggregated query.
wheres :: MonadRestrict Flat m => Predicate Flat -> m ()

-- | Add restriction to this aggregated query. Aggregated Record type
--   version.
having :: MonadRestrict Aggregated m => Predicate Aggregated -> m ()
instance (GHC.Base.Functor q, GHC.Base.Monad q) => Database.Relational.Monad.Class.MonadQualify q q


-- | This module defines monad transformer which lift to basic
--   <a>MonadQuery</a>.
module Database.Relational.Monad.Trans.Restricting

-- | Type to accumulate query restrictions. Type <tt>c</tt> is context tag
--   of restriction building like Flat (where) or Aggregated (having).
data Restrictings c m a

-- | Lift to <a>Restrictings</a>
restrictings :: Monad m => m a -> Restrictings c m a

-- | Run <a>Restrictings</a> to get <tt>QueryRestriction</tt>
extractRestrict :: (Monad m, Functor m) => Restrictings c m a -> m (a, [Predicate c])
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Restricting.Restrictings c m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Restricting.Restrictings c m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Restricting.Restrictings c m)
instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Monad.Trans.Restricting.Restrictings c)
instance (GHC.Base.Monad q, GHC.Base.Functor q) => Database.Relational.Monad.Class.MonadRestrict c (Database.Relational.Monad.Trans.Restricting.Restrictings c q)
instance Database.Relational.Monad.Class.MonadQualify q m => Database.Relational.Monad.Class.MonadQualify q (Database.Relational.Monad.Trans.Restricting.Restrictings c m)
instance Database.Relational.Monad.Class.MonadQuery q => Database.Relational.Monad.Class.MonadQuery (Database.Relational.Monad.Trans.Restricting.Restrictings c q)
instance Database.Relational.Monad.Class.MonadAggregate m => Database.Relational.Monad.Class.MonadAggregate (Database.Relational.Monad.Trans.Restricting.Restrictings c m)


-- | This module contains definitions about simple restrict context monad
--   type.
module Database.Relational.Monad.Restrict

-- | Restrict only monad type used from update statement and delete
--   statement.
type Restrict = Restrictings Flat ConfigureQuery

-- | RestrictedStatement type synonym. Record type <tt>r</tt> must be the
--   same as <a>Restrictings</a> type parameter <tt>r</tt>.
type RestrictedStatement r a = Record Flat r -> Restrict a

-- | Run <a>Restrict</a> to get <tt>QueryRestriction</tt>.
extract :: Restrict a -> Config -> (a, [Predicate Flat])


-- | This module defines monad transformer which lift from query into query
--   with ordering.
module Database.Relational.Monad.Trans.Ordering

-- | Type to accumulate ordering context. Type <tt>c</tt> is ordering term
--   record context type.
data Orderings c m a

-- | Lift to <a>Orderings</a>.
orderings :: Monad m => m a -> Orderings c m a

-- | Add ordering terms with null ordering.
orderBy' :: Monad m => Record c t -> Order -> Nulls -> Orderings c m ()

-- | Add ordering terms.
orderBy :: Monad m => Record c t -> Order -> Orderings c m ()

-- | Add ascendant ordering term.
asc :: Monad m => Record c t -> Orderings c m ()

-- | Add descendant ordering term.
desc :: Monad m => Record c t -> Orderings c m ()

-- | Run <a>Orderings</a> to get <tt>OrderingTerms</tt>
extractOrderingTerms :: (Monad m, Functor m) => Orderings c m a -> m (a, [OrderingTerm])
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Monad.Trans.Ordering.Orderings c)
instance Database.Relational.Monad.Class.MonadRestrict rc m => Database.Relational.Monad.Class.MonadRestrict rc (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance Database.Relational.Monad.Class.MonadQualify q m => Database.Relational.Monad.Class.MonadQualify q (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance Database.Relational.Monad.Class.MonadQuery m => Database.Relational.Monad.Class.MonadQuery (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance Database.Relational.Monad.Class.MonadAggregate m => Database.Relational.Monad.Class.MonadAggregate (Database.Relational.Monad.Trans.Ordering.Orderings c m)
instance Database.Relational.Monad.Class.MonadPartition c m => Database.Relational.Monad.Class.MonadPartition c (Database.Relational.Monad.Trans.Ordering.Orderings c m)


-- | This module defines monad transformer which lift to basic
--   <a>MonadQuery</a>.
module Database.Relational.Monad.Trans.Join

-- | <a>StateT</a> type to accumulate join product context.
data QueryJoin m a

-- | Lift to <a>QueryJoin</a>
join' :: Monad m => m a -> QueryJoin m a

-- | Run <a>QueryJoin</a> to get <a>JoinProduct</a>
extractProduct :: Functor m => QueryJoin m a -> m ((a, JoinProduct), Duplication)

-- | Unsafely join sub-query with this query.
unsafeSubQueryWithAttr :: Monad q => NodeAttr -> Qualified SubQuery -> QueryJoin q (Record c r)
instance GHC.Base.Monad m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Join.QueryJoin m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Join.QueryJoin m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Join.QueryJoin m)
instance Control.Monad.Trans.Class.MonadTrans Database.Relational.Monad.Trans.Join.QueryJoin
instance Database.Relational.Monad.Class.MonadQualify q m => Database.Relational.Monad.Class.MonadQualify q (Database.Relational.Monad.Trans.Join.QueryJoin m)
instance Database.Relational.Monad.Class.MonadQuery (Database.Relational.Monad.Trans.Join.QueryJoin Database.Relational.Monad.BaseType.ConfigureQuery)


-- | This module defines core query type.
module Database.Relational.Monad.Type

-- | Core query monad type used from flat(not-aggregated) query and
--   aggregated query.
type QueryCore = Restrictings Flat (QueryJoin ConfigureQuery)

-- | Extract <a>QueryCore</a> computation.
extractCore :: QueryCore a -> ConfigureQuery (((a, [Predicate Flat]), JoinProduct), Duplication)

-- | OrderedQuery monad type with placeholder type <tt>p</tt>. Record must
--   be the same as <a>Orderings</a> context type parameter <tt>c</tt>.
type OrderedQuery c m p r = Orderings c m (PlaceHolders p, Record c r)


-- | This module contains definitions about unique query type to support
--   scalar queries.
module Database.Relational.Monad.Unique

-- | Unique query monad type.
data QueryUnique a

-- | Unsafely join sub-query with this unique query.
unsafeUniqueSubQuery :: NodeAttr -> Qualified SubQuery -> QueryUnique (Record c r)

-- | Run <tt>SimpleQuery</tt> to get <a>SubQuery</a> with <tt>Qualify</tt>
--   computation.
toSubQuery :: QueryUnique (PlaceHolders p, Record c r) -> ConfigureQuery SubQuery
instance GHC.Base.Functor Database.Relational.Monad.Unique.QueryUnique
instance GHC.Base.Applicative Database.Relational.Monad.Unique.QueryUnique
instance GHC.Base.Monad Database.Relational.Monad.Unique.QueryUnique
instance Database.Relational.Monad.Class.MonadQuery Database.Relational.Monad.Unique.QueryUnique
instance Database.Relational.Monad.Class.MonadQualify Database.Relational.Monad.BaseType.ConfigureQuery Database.Relational.Monad.Unique.QueryUnique


-- | This module contains definitions about simple (not-aggregated) query
--   type.
module Database.Relational.Monad.Simple

-- | Simple (not-aggregated) query monad type.
type QuerySimple = Orderings Flat QueryCore

-- | Simple (not-aggregated) query type. <tt>SimpleQuery'</tt> p r ==
--   <a>QuerySimple</a> (<a>PlaceHolders</a> p, <a>Record</a> r).
type SimpleQuery p r = OrderedQuery Flat QueryCore p r

-- | Lift from qualified table forms into <a>QuerySimple</a>.
simple :: ConfigureQuery a -> QuerySimple a

-- | Run <a>SimpleQuery</a> to get SQL string with <tt>Qualify</tt>
--   computation.
toSQL :: SimpleQuery p r -> ConfigureQuery String

-- | Run <a>SimpleQuery</a> to get <a>SubQuery</a> with <tt>Qualify</tt>
--   computation.
toSubQuery :: SimpleQuery p r -> ConfigureQuery SubQuery


-- | This module defines monad transformer which lift from context into
--   context with assigning.
module Database.Relational.Monad.Trans.Assigning

-- | Type to accumulate assigning context. Type <tt>r</tt> is table record
--   type.
data Assignings r m a

-- | Lift to <a>Assignings</a>
assignings :: Monad m => m a -> Assignings r m a

-- | Add an assignment.
assignTo :: Monad m => Record Flat v -> AssignTarget r v -> Assignings r m ()

-- | Add and assginment.
(<-#) :: Monad m => AssignTarget r v -> Record Flat v -> Assignings r m ()
infix 4 <-#

-- | Target of assignment.
type AssignTarget r v = Pi r v

-- | Run <a>Assignings</a> to get <tt>Assignments</tt>
extractAssignments :: (Monad m, Functor m) => Assignings r m a -> m (a, Table r -> [Assignment])
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Assigning.Assignings r m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Assigning.Assignings r m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Assigning.Assignings r m)
instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Monad.Trans.Assigning.Assignings r)
instance Database.Relational.Monad.Class.MonadRestrict c m => Database.Relational.Monad.Class.MonadRestrict c (Database.Relational.Monad.Trans.Assigning.Assignings r m)
instance Database.Relational.Monad.Class.MonadQualify q m => Database.Relational.Monad.Class.MonadQualify q (Database.Relational.Monad.Trans.Assigning.Assignings r m)


-- | This module contains definitions about assignment monad type to build
--   insert statement.
module Database.Relational.Monad.Register

-- | Target register monad type used from insert statement.
type Register r = Assignings r ConfigureQuery

-- | Run <tt>InsertStatement</tt>.
extract :: Assignings r ConfigureQuery a -> Config -> (a, Table r -> [Assignment])


-- | This module contains definitions about restrict context with
--   assignment monad type.
module Database.Relational.Monad.Assign

-- | Target update monad type used from update statement and merge
--   statement.
type Assign r = Assignings r Restrict

-- | AssignStatement type synonym. Specifying assignments and restrictions
--   like update statement. Record type must be the same as <tt>Target</tt>
--   type parameter <tt>r</tt>.
type AssignStatement r a = Record Flat r -> Assign r a

-- | Run <a>Assign</a>.
extract :: Assign r a -> Config -> ((a, Table r -> [Assignment]), [Predicate Flat])


-- | This module defines monad transformer which lift from
--   <a>MonadQuery</a> into Aggregated query.
module Database.Relational.Monad.Trans.Aggregating

-- | Type to accumulate aggregating context. Type <tt>ac</tt> is
--   aggregating-context type like aggregating key set building,
--   aggregating key sets set building and partition key set building. Type
--   <tt>at</tt> is aggregating term type.
data Aggregatings ac at m a

-- | Lift to <a>Aggregatings</a>.
aggregatings :: Monad m => m a -> Aggregatings ac at m a

-- | Context type building one grouping set.
type AggregatingSetT = Aggregatings Set AggregateElem

-- | Context type building grouping sets list.
type AggregatingSetListT = Aggregatings SetList AggregateSet

-- | Context type building power group set.
type AggregatingPowerSetT = Aggregatings Power AggregateBitKey

-- | Context type building partition keys set.
type PartitioningSetT c = Aggregatings c AggregateColumnRef

-- | Run <a>Aggregatings</a> to get terms list.
extractAggregateTerms :: (Monad m, Functor m) => Aggregatings ac at m a -> m (a, [at])

-- | Context monad type to build single grouping set.
type AggregatingSet = AggregatingSetT Identity

-- | Context monad type to build grouping power set.
type AggregatingPowerSet = AggregatingPowerSetT Identity

-- | Context monad type to build grouping set list.
type AggregatingSetList = AggregatingSetListT Identity

-- | Context monad type to build partition keys set.
type PartitioningSet c = PartitioningSetT c Identity

-- | Specify key of single grouping set from Record.
key :: Record Flat r -> AggregatingSet (Record Aggregated (Maybe r))

-- | Specify key of single grouping set.
key' :: AggregateKey a -> AggregatingSet a

-- | Finalize and specify single grouping set.
set :: AggregatingSet a -> AggregatingSetList a

-- | Specify key of rollup and cube power set.
bkey :: Record Flat r -> AggregatingPowerSet (Record Aggregated (Maybe r))

-- | Finalize grouping power set as rollup power set.
rollup :: AggregatingPowerSet a -> AggregateKey a

-- | Finalize grouping power set as cube power set.
cube :: AggregatingPowerSet a -> AggregateKey a

-- | Finalize grouping set list.
groupingSets :: AggregatingSetList a -> AggregateKey a
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Monad.Trans.Aggregating.Aggregatings ac at m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Monad.Trans.Aggregating.Aggregatings ac at m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Monad.Trans.Aggregating.Aggregatings ac at m)
instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Monad.Trans.Aggregating.Aggregatings ac at)
instance GHC.Base.Monad m => Database.Relational.Monad.Class.MonadPartition c (Database.Relational.Monad.Trans.Aggregating.PartitioningSetT c m)
instance Database.Relational.Monad.Class.MonadRestrict c m => Database.Relational.Monad.Class.MonadRestrict c (Database.Relational.Monad.Trans.Aggregating.AggregatingSetT m)
instance Database.Relational.Monad.Class.MonadQualify q m => Database.Relational.Monad.Class.MonadQualify q (Database.Relational.Monad.Trans.Aggregating.AggregatingSetT m)
instance Database.Relational.Monad.Class.MonadQuery m => Database.Relational.Monad.Class.MonadQuery (Database.Relational.Monad.Trans.Aggregating.AggregatingSetT m)
instance Database.Relational.Monad.Class.MonadQuery m => Database.Relational.Monad.Class.MonadAggregate (Database.Relational.Monad.Trans.Aggregating.AggregatingSetT m)


-- | This module contains definitions about aggregated query type.
module Database.Relational.Monad.Aggregate

-- | Aggregated query monad type.
type QueryAggregate = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore))

-- | Aggregated query type. <a>AggregatedQuery</a> p r ==
--   <a>QueryAggregate</a> (<a>PlaceHolders</a> p, <a>Record</a>
--   <a>Aggregated</a> r).
type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r

-- | Run <a>AggregatedQuery</a> to get SQL with <a>ConfigureQuery</a>
--   computation.
toSQL :: AggregatedQuery p r -> ConfigureQuery String

-- | Run <a>AggregatedQuery</a> to get <a>SubQuery</a> with
--   <a>ConfigureQuery</a> computation.
toSubQuery :: AggregatedQuery p r -> ConfigureQuery SubQuery

-- | Partition monad type for partition-by clause.
type Window c = Orderings c (PartitioningSet c)

-- | Operator to make record of window function result using built
--   <a>Window</a> monad.
over :: SqlContext c => Record OverWindow a -> Window c () -> Record c a
infix 8 `over`
instance Database.Relational.Monad.Class.MonadRestrict Database.Relational.Internal.ContextType.Flat q => Database.Relational.Monad.Class.MonadRestrict Database.Relational.Internal.ContextType.Flat (Database.Relational.Monad.Trans.Restricting.Restrictings Database.Relational.Internal.ContextType.Aggregated q)


-- | This module integrate monadic operations to compose complex queries
--   with re-usable Relation type.
module Database.Relational.Relation

-- | Simple <a>Relation</a> from <a>Table</a>.
table :: Table r -> Relation () r

-- | Inferred <a>Relation</a>.
derivedRelation :: TableDerivable r => Relation () r

-- | Interface to derive <a>Table</a> type object.
tableOf :: TableDerivable r => Relation () r -> Table r

-- | Finalize <a>QuerySimple</a> monad and generate <a>Relation</a>.
relation :: QuerySimple (Record Flat r) -> Relation () r

-- | Finalize <a>QuerySimple</a> monad and generate <a>Relation</a> with
--   place-holder parameter <tt>p</tt>.
relation' :: SimpleQuery p r -> Relation p r

-- | Finalize <a>QueryAggregate</a> monad and geneate <a>Relation</a>.
aggregateRelation :: QueryAggregate (Record Aggregated r) -> Relation () r

-- | Finalize <a>QueryAggregate</a> monad and geneate <a>Relation</a> with
--   place-holder parameter <tt>p</tt>.
aggregateRelation' :: AggregatedQuery p r -> Relation p r

-- | Unique relation type to compose scalar queries.
data UniqueRelation p c r

-- | Unsafely specify unique relation.
unsafeUnique :: Relation p r -> UniqueRelation p c r

-- | Discard unique attribute.
unUnique :: UniqueRelation p c r -> Relation p r

-- | Finalize <a>QueryUnique</a> monad and generate <a>UniqueRelation</a>.
uniqueRelation' :: QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r

-- | Aggregated <a>UniqueRelation</a>.
aggregatedUnique :: Relation ph r -> Pi r a -> (Record Flat a -> Record Aggregated b) -> UniqueRelation ph Flat b

-- | Join sub-query. Query result is not <a>Maybe</a>.
query :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat r)

-- | Join sub-query. Query result is <a>Maybe</a>. The combinations of
--   <a>query</a> and <a>queryMaybe</a> express inner joins, left outer
--   joins, right outer joins, and full outer joins. Here is an example of
--   a right outer join:
--   
--   <pre>
--   outerJoin = relation $ do
--     e &lt;- queryMaybe employee
--     d &lt;- query department
--     on $ e ?! E.deptId' .=. just (d ! D.deptId')
--     return $ (,) |$| e |*| d
--   </pre>
queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat (Maybe r))

-- | List sub-query, for <i>IN</i> and <i>EXIST</i>.
queryList :: MonadQualify ConfigureQuery m => Relation () r -> m (RecordList (Record c) r)

-- | List sub-query, for <i>IN</i> and <i>EXIST</i> with place-holder
--   parameter <tt>p</tt>.
queryList' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, RecordList (Record c) r)

-- | Scalar sub-query.
queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation () c r -> m (Record c (Maybe r))

-- | Scalar sub-query with place-holder parameter <tt>p</tt>.
queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r))

-- | Join unique sub-query with place-holder parameter <tt>p</tt>.
uniqueQuery' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r)

-- | Join unique sub-query with place-holder parameter <tt>p</tt>. Query
--   result is <a>Maybe</a>.
uniqueQueryMaybe' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c (Maybe r))


-- | This module defines set operations on monadic Relation operations.
module Database.Relational.Set

-- | Restriction predicate function type for direct style join operator,
--   used on predicates of direct join style as follows.
--   
--   <pre>
--   do xy &lt;- query $
--            relX <a>inner</a> relY <a>on'</a> [ x y -&gt; ... ] -- this lambda form has JoinRestriction type
--      ...
--   </pre>
type JoinRestriction a b = Record Flat a -> Record Flat b -> Predicate Flat

-- | Direct inner join with place-holder parameters.
inner' :: Relation pa a -> Relation pb b -> [JoinRestriction a b] -> Relation (pa, pb) (a, b)
infixl 8 `inner'`

-- | Direct left outer join with place-holder parameters.
left' :: Relation pa a -> Relation pb b -> [JoinRestriction a (Maybe b)] -> Relation (pa, pb) (a, Maybe b)
infixl 8 `left'`

-- | Direct right outer join with place-holder parameters.
right' :: Relation pa a -> Relation pb b -> [JoinRestriction (Maybe a) b] -> Relation (pa, pb) (Maybe a, b)
infixl 8 `right'`

-- | Direct full outer join with place-holder parameters.
full' :: Relation pa a -> Relation pb b -> [JoinRestriction (Maybe a) (Maybe b)] -> Relation (pa, pb) (Maybe a, Maybe b)
infixl 8 `full'`

-- | Direct inner join.
inner :: Relation () a -> Relation () b -> [JoinRestriction a b] -> Relation () (a, b)
infixl 8 `inner`

-- | Direct left outer join.
left :: Relation () a -> Relation () b -> [JoinRestriction a (Maybe b)] -> Relation () (a, Maybe b)
infixl 8 `left`

-- | Direct right outer join.
right :: Relation () a -> Relation () b -> [JoinRestriction (Maybe a) b] -> Relation () (Maybe a, b)
infixl 8 `right`

-- | Direct full outer join.
full :: Relation () a -> Relation () b -> [JoinRestriction (Maybe a) (Maybe b)] -> Relation () (Maybe a, Maybe b)
infixl 8 `full`

-- | Apply restriction for direct join style.
on' :: ([JoinRestriction a b] -> Relation pc (a, b)) -> [JoinRestriction a b] -> Relation pc (a, b)
infixl 8 `on'`

-- | Union of two relations.
union :: Relation () a -> Relation () a -> Relation () a
infixl 7 `union`

-- | Subtraction of two relations.
except :: Relation () a -> Relation () a -> Relation () a
infixl 7 `except`

-- | Intersection of two relations.
intersect :: Relation () a -> Relation () a -> Relation () a
infixl 8 `intersect`

-- | Union of two relations. Not distinct.
unionAll :: Relation () a -> Relation () a -> Relation () a
infixl 7 `unionAll`

-- | Subtraction of two relations. Not distinct.
exceptAll :: Relation () a -> Relation () a -> Relation () a
infixl 7 `exceptAll`

-- | Intersection of two relations. Not distinct.
intersectAll :: Relation () a -> Relation () a -> Relation () a
infixl 8 `intersectAll`

-- | Union of two relations with place-holder parameters.
union' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 7 `union'`

-- | Subtraction of two relations with place-holder parameters.
except' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 7 `except'`

-- | Intersection of two relations with place-holder parameters.
intersect' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 8 `intersect'`

-- | Union of two relations with place-holder parameters. Not distinct.
unionAll' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 7 `unionAll'`

-- | Subtraction of two relations with place-holder parameters. Not
--   distinct.
exceptAll' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 7 `exceptAll'`

-- | Intersection of two relations with place-holder parameters. Not
--   distinct.
intersectAll' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 8 `intersectAll'`


-- | This module defines effect statements like update and delete.
module Database.Relational.Effect

-- | Restriction type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
data Restriction p r

-- | Finalize <tt>Restrict</tt> monad and generate <a>Restriction</a>.
restriction :: RestrictedStatement r () -> Restriction () r

-- | Finalize <tt>Restrict</tt> monad and generate <a>Restriction</a> with
--   place-holder parameter <tt>p</tt>
restriction' :: RestrictedStatement r (PlaceHolders p) -> Restriction p r

-- | UpdateTarget type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
data UpdateTarget p r

-- | Finalize <tt>Target</tt> monad and generate <a>UpdateTarget</a>.
updateTarget :: AssignStatement r () -> UpdateTarget () r

-- | Finalize <tt>Target</tt> monad and generate <a>UpdateTarget</a> with
--   place-holder parameter <tt>p</tt>.
updateTarget' :: AssignStatement r (PlaceHolders p) -> UpdateTarget p r

-- | Lift <a>Restriction</a> to <a>UpdateTarget</a>. Update target columns
--   are all.
liftTargetAllColumn :: PersistableWidth r => Restriction () r -> UpdateTarget r r

-- | Lift <a>Restriction</a> to <a>UpdateTarget</a>. Update target columns
--   are all. With placefolder type <tt>p</tt>.
liftTargetAllColumn' :: PersistableWidth r => Restriction p r -> UpdateTarget (r, p) r

-- | Finalize <tt>Restrict</tt> monad and generate <a>UpdateTarget</a>.
--   Update target columns are all.
updateTargetAllColumn :: PersistableWidth r => RestrictedStatement r () -> UpdateTarget r r

-- | Finalize <tt>Restrict</tt> monad and generate <a>UpdateTarget</a>.
--   Update target columns are all. With placefolder type <tt>p</tt>.
updateTargetAllColumn' :: PersistableWidth r => RestrictedStatement r (PlaceHolders p) -> UpdateTarget (r, p) r

-- | InsertTarget type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
data InsertTarget p r

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</a>.
insertTarget :: Register r () -> InsertTarget () r

-- | Finalize <tt>Target</tt> monad and generate <a>UpdateTarget</a> with
--   place-holder parameter <tt>p</tt>.
insertTarget' :: Register r (PlaceHolders p) -> InsertTarget p r

-- | parametalized <a>Register</a> monad from <a>Pi</a>
piRegister :: PersistableWidth r => Pi r r' -> Register r (PlaceHolders r')

-- | SQL WHERE clause <a>StringSQL</a> string from <a>Restriction</a>.
sqlWhereFromRestriction :: Config -> Table r -> Restriction p r -> StringSQL

-- | SQL SET clause and WHERE clause <a>StringSQL</a> string from
--   <a>UpdateTarget</a>
sqlFromUpdateTarget :: Config -> Table r -> UpdateTarget p r -> StringSQL

-- | Make <a>StringSQL</a> string of SQL INSERT record chunk statement from
--   <a>InsertTarget</a>
sqlChunkFromInsertTarget :: Config -> Table r -> InsertTarget p r -> (StringSQL, Int)

-- | Make <a>StringSQL</a> string of SQL INSERT statement from
--   <a>InsertTarget</a>
sqlFromInsertTarget :: Config -> Table r -> InsertTarget p r -> StringSQL
instance Database.Relational.Table.TableDerivable r => GHC.Show.Show (Database.Relational.Effect.UpdateTarget p r)
instance Database.Relational.Table.TableDerivable r => GHC.Show.Show (Database.Relational.Effect.Restriction p r)


-- | This module defines typed SQL.
module Database.Relational.Type

-- | Query type with place-holder parameter <tt>p</tt> and query result
--   type <tt>a</tt>.
newtype Query p a
Query :: String -> Query p a
[untypeQuery] :: Query p a -> String

-- | Unsafely make typed <a>Query</a> from SQL string.
unsafeTypedQuery :: String -> Query p a

-- | From <a>Relation</a> into typed <a>Query</a> with suffix SQL words.
relationalQuery' :: Relation p r -> QuerySuffix -> Query p r

-- | From <a>Relation</a> into typed <a>Query</a>.
relationalQuery :: Relation p r -> Query p r

-- | From <a>Relation</a> into untyped SQL query string.
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String

-- | Update type with key type <tt>p</tt> and update record type
--   <tt>a</tt>. Columns to update are record columns other than key
--   columns, So place-holder parameter type is the same as record type
--   <tt>a</tt>.
data KeyUpdate p a
KeyUpdate :: Pi a p -> String -> KeyUpdate p a
[updateKey] :: KeyUpdate p a -> Pi a p
[untypeKeyUpdate] :: KeyUpdate p a -> String

-- | Unsafely make typed <a>KeyUpdate</a> from SQL string.
unsafeTypedKeyUpdate :: Pi a p -> String -> KeyUpdate p a

-- | Make typed <a>KeyUpdate</a> from <a>Table</a> and key columns selector
--   <a>Pi</a>.
typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a

-- | Make typed <a>KeyUpdate</a> object using derived info specified by
--   <a>Relation</a> type.
typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r

-- | Make typed <a>KeyUpdate</a> from derived table and key columns
--   selector <a>Pi</a>.
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

-- | Update type with place-holder parameter <tt>p</tt>.
newtype Update p
Update :: String -> Update p
[untypeUpdate] :: Update p -> String

-- | Unsafely make typed <a>Update</a> from SQL string.
unsafeTypedUpdate :: String -> Update p

-- | Make typed <a>Update</a> from <a>Config</a>, <a>Table</a> and
--   <a>UpdateTarget</a>.
typedUpdate' :: Config -> Table r -> UpdateTarget p r -> Update p

-- | Make typed <a>Update</a> using <a>defaultConfig</a>, <a>Table</a> and
--   <a>UpdateTarget</a>.
typedUpdate :: Table r -> UpdateTarget p r -> Update p

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>AssignStatement</a>
derivedUpdate' :: TableDerivable r => Config -> AssignStatement r (PlaceHolders p) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>AssignStatement</a>
derivedUpdate :: TableDerivable r => AssignStatement r (PlaceHolders p) -> Update p

-- | Make typed <a>Update</a> from <a>Table</a> and <a>Restriction</a>.
--   Update target is all column.
typedUpdateAllColumn :: PersistableWidth r => Table r -> Restriction p r -> Update (r, p)

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>AssignStatement</a>. Update target is all column.
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> RestrictedStatement r (PlaceHolders p) -> Update (r, p)

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>AssignStatement</a>. Update target is all column.
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => RestrictedStatement r (PlaceHolders p) -> Update (r, p)

-- | Make untyped update SQL string from <a>Table</a> and
--   <a>UpdateTarget</a>.
updateSQL :: Config -> Table r -> UpdateTarget p r -> String

-- | Insert type to insert record type <tt>a</tt>.
data Insert a
Insert :: String -> Maybe (String, Int) -> Insert a
[untypeInsert] :: Insert a -> String
[chunkedInsert] :: Insert a -> Maybe (String, Int)

-- | Statement to use chunked insert
untypeChunkInsert :: Insert a -> String

-- | Size to use chunked insert
chunkSizeOfInsert :: Insert a -> Int

-- | Unsafely make typed <a>Insert</a> from single insert and chunked
--   insert SQL.
unsafeTypedInsert' :: String -> String -> Int -> Insert a

-- | Unsafely make typed <a>Insert</a> from single insert SQL.
unsafeTypedInsert :: String -> Insert a

-- | Make typed <a>Insert</a> from <a>Table</a> and columns selector
--   <a>Pi</a> with configuration parameter.
typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r'

-- | Make typed <a>Insert</a> from <a>Table</a> and columns selector
--   <a>Pi</a>.
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'

-- | Table type inferred <a>Insert</a>.
derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'

-- | Make typed <a>Insert</a> from <a>Config</a>, <a>Table</a> and monadic
--   builded <a>InsertTarget</a> object.
typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p

-- | Make typed <a>Insert</a> from <a>Table</a> and monadic builded
--   <a>InsertTarget</a> object.
typedInsertValue :: Table r -> InsertTarget p r -> Insert p

-- | Make typed <a>Insert</a> from <a>Config</a>, derived table and monadic
--   builded <a>Register</a> object.
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

-- | Make typed <a>Insert</a> from <a>defaultConfig</a>, derived table and
--   monadic builded <a>Register</a> object.
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | InsertQuery type.
newtype InsertQuery p
InsertQuery :: String -> InsertQuery p
[untypeInsertQuery] :: InsertQuery p -> String

-- | Unsafely make typed <a>InsertQuery</a> from SQL string.
unsafeTypedInsertQuery :: String -> InsertQuery p

-- | Make typed <a>InsertQuery</a> from columns selector <a>Table</a>,
--   <a>Pi</a> and <a>Relation</a> with configuration parameter.
typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p

-- | Make typed <a>InsertQuery</a> from columns selector <a>Table</a>,
--   <a>Pi</a> and <a>Relation</a>.
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p

-- | Table type inferred <a>InsertQuery</a>.
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

-- | Make untyped insert select SQL string from <a>Table</a>, <a>Pi</a> and
--   <a>Relation</a>.
insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String

-- | Delete type with place-holder parameter <tt>p</tt>.
newtype Delete p
Delete :: String -> Delete p
[untypeDelete] :: Delete p -> String

-- | Unsafely make typed <a>Delete</a> from SQL string.
unsafeTypedDelete :: String -> Delete p

-- | Make typed <a>Delete</a> from <a>Config</a>, <a>Table</a> and
--   <a>Restriction</a>.
typedDelete' :: Config -> Table r -> Restriction p r -> Delete p

-- | Make typed <a>Delete</a> from <a>Table</a> and <a>Restriction</a>.
typedDelete :: Table r -> Restriction p r -> Delete p

-- | Make typed <a>Delete</a> from <a>Config</a>, derived table and
--   <tt>RestrictContext</tt>
derivedDelete' :: TableDerivable r => Config -> RestrictedStatement r (PlaceHolders p) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <tt>RestrictContext</tt>
derivedDelete :: TableDerivable r => RestrictedStatement r (PlaceHolders p) -> Delete p

-- | Make untyped delete SQL string from <a>Table</a> and
--   <a>Restriction</a>.
deleteSQL :: Config -> Table r -> Restriction p r -> String

-- | Untype interface for typed no-result type statments with single type
--   parameter which represents place-holder parameter <tt>p</tt>.
class UntypeableNoFetch s
untypeNoFetch :: UntypeableNoFetch s => s p -> String
instance Database.Relational.Type.UntypeableNoFetch Database.Relational.Type.Insert
instance Database.Relational.Type.UntypeableNoFetch Database.Relational.Type.InsertQuery
instance Database.Relational.Type.UntypeableNoFetch Database.Relational.Type.Update
instance Database.Relational.Type.UntypeableNoFetch Database.Relational.Type.Delete
instance GHC.Show.Show (Database.Relational.Type.Delete p)
instance GHC.Show.Show (Database.Relational.Type.InsertQuery p)
instance GHC.Show.Show (Database.Relational.Type.Insert a)
instance GHC.Show.Show (Database.Relational.Type.Update p)
instance GHC.Show.Show (Database.Relational.Type.KeyUpdate p a)
instance GHC.Show.Show (Database.Relational.Type.Query p a)


-- | This module provides structures about sequence tables.
module Database.Relational.Sequence

-- | Basic record to express sequence table
data Sequence s i
Sequence :: Table s -> (s -> i) -> Pi s i -> Sequence s i
[seqTable] :: Sequence s i -> Table s
[seqExtract] :: Sequence s i -> s -> i
[seqKey] :: Sequence s i -> Pi s i

-- | Infer <a>Relation</a> of sequence table
seqRelation :: TableDerivable s => Sequence s i -> Relation () s

-- | Unsafely specify sequence table.
unsafeSpecifySequence :: TableDerivable s => (s -> i) -> Pi s i -> Sequence s i

-- | <a>Sequence</a> derivation rule
class TableDerivable s => SequenceDerivable s i | s -> i
derivedSequence :: SequenceDerivable s i => Sequence s i

-- | Derivation rule for binding between <a>Table</a> and <a>Sequence</a>
class (TableDerivable r, SequenceDerivable s i) => Binding r s i | r -> s
fromTable :: Binding r s i => Table r -> Sequence s i

-- | Derive <a>Sequence</a> from corresponding <a>Relation</a>
fromRelation :: Binding r s i => Relation () r -> Sequence s i

-- | Sequence number type for record type <tt>r</tt>
data Number r i

-- | Unsafely specify sequence number.
unsafeSpecifyNumber :: Binding r s i => i -> Number r i

-- | Get untyped sequence number.
extractNumber :: Number r i -> i

-- | Unsafely apply sequence number.
($$!) :: (i -> r) -> Number r i -> r

-- | Unsafely apply sequence number. Only safe to build corresponding
--   record type.
($$) :: Binding r s i => (i -> r) -> Number r i -> r

-- | Update statement for sequence table
updateNumber :: (PersistableWidth s, Integral i, ShowConstantTermsSQL i) => i -> Sequence s i -> Update ()
instance GHC.Show.Show i => GHC.Show.Show (Database.Relational.Sequence.Number r i)
instance GHC.Classes.Ord i => GHC.Classes.Ord (Database.Relational.Sequence.Number r i)
instance GHC.Classes.Eq i => GHC.Classes.Eq (Database.Relational.Sequence.Number r i)


-- | This module defines typed SQLs derived from type informations.
module Database.Relational.Derives

-- | Query restricted with specified key.
specifiedKey :: PersistableWidth p => Pi a p -> Relation () a -> Relation p a

-- | Query restricted with specified unique key.
unique :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a

-- | Query restricted with specified primary key.
primary' :: PersistableWidth p => Key Primary a p -> Relation () a -> Relation p a

-- | Query restricted with inferred primary key.
primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a

-- | Typed <a>KeyUpdate</a> using specified constraint key.
updateByConstraintKey :: Table r -> Key c r p -> KeyUpdate p r

-- | Typed <a>KeyUpdate</a> using inferred primary key.
primaryUpdate :: (HasConstraintKey Primary r p) => Table r -> KeyUpdate p r

-- | Convert from Haskell type <tt>r</tt> into SQL value <tt>q</tt> list
--   expected by update form like
--   
--   <i>UPDATE <a>table</a> SET c0 = ?, c1 = ?, ..., cn = ? WHERE key0 = ?
--   AND key1 = ? AND key2 = ? ... </i>
--   
--   using derived <tt>RecordToSql</tt> proof object.
updateValuesWithKey :: ToSql q r => Pi r p -> r -> [q]

-- | <a>UniqueRelation</a> inferred from table.
derivedUniqueRelation :: TableDerivable r => Key Unique r k -> Record c k -> UniqueRelation () c r


-- | This module is integrated module of Query.
module Database.Relational


-- | This module defines templates for Haskell record type and type class
--   instances to define column projection on SQL query like Haskell
--   records. Templates are generated by also using functions of
--   <a>Database.Record.TH</a> module, so mapping between list of untyped
--   SQL type and Haskell record type will be done too.
module Database.Relational.TH

-- | Generate all templtes about table using specified naming rule.
defineTable :: Config -> String -> String -> [(String, TypeQ)] -> [Name] -> [Int] -> Maybe Int -> Q [Dec]

-- | Unsafely inlining SQL string <a>Query</a> in compile type.
unsafeInlineQuery :: TypeQ -> TypeQ -> String -> VarName -> Q [Dec]

-- | Inlining composed <a>Query</a> in compile type.
inlineQuery :: Name -> Relation p r -> Config -> QuerySuffix -> String -> Q [Dec]

-- | Make templates about table, column and haskell record using specified
--   naming rule.
defineTableTypesAndRecord :: Config -> String -> String -> [(String, TypeQ)] -> [Name] -> Q [Dec]

-- | Rule template to infer primary key.
defineHasPrimaryKeyInstance :: TypeQ -> TypeQ -> [Int] -> Q [Dec]

-- | Rule template to infer primary key.
defineHasPrimaryKeyInstanceWithConfig :: Config -> String -> String -> TypeQ -> [Int] -> Q [Dec]

-- | Rule template to infer not-null key.
defineHasNotNullKeyInstance :: TypeQ -> Int -> Q [Dec]

-- | Rule template to infer not-null key.
defineHasNotNullKeyInstanceWithConfig :: Config -> String -> String -> Int -> Q [Dec]

-- | <a>ScalarDegree</a> instance templates.
defineScalarDegree :: TypeQ -> Q [Dec]

-- | Make projection path templates using default naming rule.
defineColumnsDefault :: ConName -> [(String, TypeQ)] -> Q [Dec]

-- | Make overloaded projection path templates using default naming rule.
defineOverloadedColumnsDefault :: ConName -> [(String, TypeQ)] -> Q [Dec]

-- | Projection path <a>Pi</a> templates.
defineColumns :: ConName -> [(VarName, TypeQ)] -> Q [Dec]

-- | Overloaded projection path <a>Pi</a> templates.
defineOverloadedColumns :: ConName -> [(String, TypeQ)] -> Q [Dec]

-- | Make templates of projection paths for tuple types.
defineTuplePi :: Int -> Q [Dec]

-- | <a>Table</a> and <a>Relation</a> templates.
defineTableTypes :: VarName -> VarName -> VarName -> VarName -> TypeQ -> String -> [String] -> Q [Dec]

-- | Make templates about table and column metadatas using specified naming
--   rule.
defineTableTypesWithConfig :: Config -> String -> String -> [(String, TypeQ)] -> Q [Dec]

-- | Template of derived primary <a>Query</a>.
definePrimaryQuery :: VarName -> TypeQ -> TypeQ -> ExpQ -> Q [Dec]

-- | Template of derived primary <tt>Update</tt>.
definePrimaryUpdate :: VarName -> TypeQ -> TypeQ -> ExpQ -> Q [Dec]

-- | Make <tt>TableDerivation</tt> variable expression template from table
--   name using default naming rule.
derivationExpDefault :: String -> ExpQ

-- | Make <a>Table</a> variable expression template from table name using
--   default naming rule.
tableVarExpDefault :: String -> ExpQ

-- | Make <a>Relation</a> variable expression template from table name
--   using specified naming rule.
relationVarExp :: Config -> String -> String -> ExpQ

-- | SQL templates derived from primary key.
defineSqlsWithPrimaryKey :: VarName -> VarName -> TypeQ -> TypeQ -> ExpQ -> ExpQ -> Q [Dec]

-- | SQL templates derived from primary key using default naming rule.
defineSqlsWithPrimaryKeyDefault :: String -> TypeQ -> TypeQ -> ExpQ -> ExpQ -> Q [Dec]

-- | Generate all templates against defined record like type constructor
--   other than depending on sql-value type.
makeRelationalRecordDefault :: Name -> Q [Dec]

-- | Generate all templates against defined record like type constructor
--   other than depending on sql-value type.
makeRelationalRecordDefault' :: Config -> Name -> Q [Dec]

-- | Extract param type and result type from defined Relation
reifyRelation :: Name -> Q (Type, Type)


-- | This module contains backward compatibility definitions of
--   relational-query &lt;= 0.9.*

-- | <i>Deprecated: backward compatibility definitions relational-query
--   &lt;= 0.9.*</i>
module Database.Relational.Compat

-- | deprecated <a>Projection</a> type replaced by <a>Record</a> type.
type Projection = Record

-- | deprecated <a>Projection</a> type replaced by <a>Record</a> type.
type ListProjection = RecordList

-- | Define product isomorphic inference rule to specify record constructor
class ProductConstructor c
productConstructor :: ProductConstructor c => c

-- | deprecated <a>ProjectableFunctor</a> class replaced by
--   <a>ProductIsoFunctor</a> class.
type ProjectableFunctor = ProductIsoFunctor
(|$|) :: ProductIsoFunctor f => forall a b. ProductConstructor (a -> b) => (a -> b) -> f a -> f b
infixl 4 |$|

-- | deprecated <a>ProjectableApplicative</a> class replaced by
--   <a>ProductIsoApplicative</a> class.
type ProjectableApplicative = ProductIsoApplicative
(|*|) :: ProductIsoApplicative f => forall a b. () => f (a -> b) -> f a -> f b
infixl 4 |*|

-- | deprecated <a>ProjectableIdZip</a> class replaced by
--   <a>ProductIsoEmpty</a> class.
type ProjectableIdZip p = ProductIsoEmpty p ()

-- | deprecated right-id-law definition replaced by <a>peRight</a>
rightId :: ProjectableIdZip p => p (a, ()) -> p a

-- | deprecated left-id-law definition replaced by <a>peLeft</a>
leftId :: ProjectableIdZip p => p ((), a) -> p a

-- | Interface to project SQL terms unsafely.
class SqlProjectable p

-- | Unsafely project from SQL expression terms.
unsafeProjectSqlTerms :: SqlProjectable p => [StringSQL] -> p t

-- | Deprecated. Use Database.Relational.unsafeProjectSql instead of this.
unsafeProjectSql :: SqlProjectable p => String -> p a

-- | Interface to get SQL expression from a record.
class ProjectableShowSql p
unsafeShowSql' :: ProjectableShowSql p => p a -> StringSQL

-- | Deprecated. Use Database.Relational.unsafeShowSql instead of this.
unsafeShowSql :: ProjectableShowSql p => p a -> String

-- | deprecated map definition for Pi type. use (<a>|$|</a>) instead of
--   this.
pfmap :: ProductConstructor (a -> b) => (a -> b) -> Pi r a -> Pi r b

-- | deprecated ap definition for Pi type. use (<a>|*|</a>) instead of
--   this.
pap :: Pi r (a -> b) -> Pi r a -> Pi r b

-- | deprecated empty definition for Pi type. use <a>pureE</a> instead of
--   this.
pzero :: Pi a ()
instance Database.Relational.Compat.ProjectableShowSql (Database.Relational.SqlSyntax.Types.Record c)
instance Database.Relational.Projectable.Unsafe.SqlContext c => Database.Relational.Compat.SqlProjectable (Database.Relational.SqlSyntax.Types.Record c)


-- | This module contains backword compatibility interface of
--   relational-query &lt;= 0.9.*

-- | <i>Deprecated: Should switch namespace to Database.Relational</i>
module Database.Relational.Query


-- | 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:
--   
--   <ul>
--   <li><a>https://github.com/tomjaguarpaw/haskell-opaleye</a></li>
--   
--   <li><a>https://github.com/khibino/haskell-relational-record/issues/19</a></li>
--   </ul>
--   
--   Importing this module instead of <a>Database.Relational.Query</a>
--   enables to build query using arrow combinators.
module Database.Relational.Arrow

-- | Same as <a>all'</a>. Arrow version.
all' :: MonadQuery m => QueryA m () ()

-- | Same as <a>distinct</a>. Arrow version.
distinct :: MonadQuery m => QueryA m () ()

-- | Same as <a>query</a>. 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)

-- | Same as <a>queryMaybe</a>. 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))

-- | Same as <a>query'</a>. 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)

-- | Same as <a>queryMaybe'</a>. 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))

-- | Same as <a>queryList</a>. 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)

-- | Same as <a>queryList'</a>. 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)

-- | Same as <a>queryList</a> to pass this result to <a>exists</a>
--   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)

-- | Same as <a>queryList'</a> to pass this result to <a>exists</a>
--   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)

-- | Same as <a>queryList</a>. Arrow version. Useful for no reference cases
--   to local projected records.
queryListU :: MonadQualify ConfigureQuery m => Relation () r -> QueryA m () (RecordList (Record c) r)

-- | Same as <a>queryList'</a>. 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)

-- | Same as <a>queryScalar</a>. 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))

-- | Same as <a>queryScalar'</a>. 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))

-- | Same as <a>queryScalar</a>. 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))

-- | Same as <a>queryScalar'</a>. 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))

-- | Same as <a>uniqueQuery'</a>. Arrow version. The result arrow is not
--   injected by local projected records.
uniqueQuery' :: UniqueRelation p c r -> QueryA QueryUnique () (PlaceHolders p, Record c r)

-- | Same as <a>uniqueQueryMaybe'</a>. Arrow version. The result arrow is
--   not injected by local projected records.
uniqueQueryMaybe' :: UniqueRelation p c r -> QueryA QueryUnique () (PlaceHolders p, Record c (Maybe r))

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

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

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

-- | Same as <a>groupBy</a>. 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)

-- | Same as <a>placeholder</a>. 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)

-- | Same as <a>relation</a>. Finalize query-building arrow instead of
--   query-building monad.
relation :: QuerySimple () (Record Flat r) -> Relation () r

-- | Same as <a>relation'</a>. Finalize query-building arrow instead of
--   query-building monad.
relation' :: QuerySimple () (PlaceHolders p, Record Flat r) -> Relation p r

-- | Same as <a>aggregateRelation</a>. Finalize query-building arrow
--   instead of query-building monad.
aggregateRelation :: QueryAggregate () (Record Aggregated r) -> Relation () r

-- | Same as <a>aggregateRelation'</a>. Finalize query-building arrow
--   instead of query-building monad.
aggregateRelation' :: QueryAggregate () (PlaceHolders p, Record Aggregated r) -> Relation p r

-- | Same as <a>uniqueRelation'</a>. Finalize query-building arrow instead
--   of query-building monad.
uniqueRelation' :: QueryUnique () (PlaceHolders p, Record c r) -> UniqueRelation p c r

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

-- | Same as <a>key</a>. This arrow is designed to be injected by local
--   flat-records.
key :: AggregatingSet (Record Flat r) (Record Aggregated (Maybe r))

-- | Same as <a>key'</a>. This arrow is designed to be injected by local
--   <tt>AggregteKey</tt>.
key' :: AggregatingSet (AggregateKey a) a

-- | Same as <a>set</a>. This arrow is designed to be injected by locally
--   built <tt>AggregtingSet</tt> arrow.
set :: AggregatingSetList (AggregatingSet () a) a

-- | Same as <a>bkey</a>. This arrow is designed to be injected by local
--   flat-records.
bkey :: AggregatingPowerSet (Record Flat r) (Record Aggregated (Maybe r))

-- | Same as <a>rollup</a>. Finalize locally built
--   <a>AggregatingPowerSet</a>.
rollup :: AggregatingPowerSet () a -> AggregateKey a

-- | Same as <a>cube</a>. Finalize locally built
--   <a>AggregatingPowerSet</a>.
cube :: AggregatingPowerSet () a -> AggregateKey a

-- | Same as <a>groupingSets</a>. Finalize locally built
--   <a>AggregatingSetList</a>.
groupingSets :: AggregatingSetList () a -> AggregateKey a

-- | Same as <a>orderBy'</a>. The result arrow is designed to be injected
--   by local projected records.
orderBy' :: Monad m => Order -> Nulls -> Orderings c m (Record c t) ()

-- | Same as <a>orderBy</a>. The result arrow is designed to be injected by
--   local projected records.
orderBy :: Monad m => Order -> Orderings c m (Record c t) ()

-- | Same as <a>asc</a>. The result arrow is designed to be injected by
--   local projected records.
asc :: Monad m => Orderings c m (Record c t) ()

-- | Same as <a>desc</a>. The result arrow is designed to be injected by
--   local projected records.
desc :: Monad m => Orderings c m (Record c t) ()

-- | Same as <a>partitionBy</a>. The result arrow is designed to be
--   injected by local projected records.
partitionBy :: Window c (Record c r) ()

-- | Same as <a>over</a>. Make record of window function result using built
--   <a>Window</a> arrow.
over :: SqlContext c => Record OverWindow a -> Window c () () -> Record c a
infix 8 `over`

-- | Make <a>AssignTarget</a> into arrow which is designed to be injected
--   by assignees of local projected record.
assign :: Monad m => AssignTarget r v -> Assignings r m (Record Flat v) ()

-- | Same as <a>derivedUpdate'</a>. Make <a>Update</a> from assigning
--   statement arrow using configuration.
derivedUpdate' :: TableDerivable r => Config -> AssignStatement r (PlaceHolders p) -> Update p

-- | Same as <a>derivedUpdate</a>. Make <a>Update</a> from assigning
--   statement arrow.
derivedUpdate :: TableDerivable r => AssignStatement r (PlaceHolders p) -> Update p

-- | Same as <a>derivedInsertValue'</a>. Make <a>Insert</a> from register
--   arrow using configuration.
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

-- | Same as <a>derivedInsertValue</a>. Make <a>Insert</a> from register
--   arrow.
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Same as <a>derivedDelete'</a>. Make <a>Update</a> from restrict
--   statement arrow using configuration.
derivedDelete' :: TableDerivable r => Config -> RestrictedStatement r (PlaceHolders p) -> Delete p

-- | Same as <a>derivedDelete</a>. Make <a>Update</a> from restrict
--   statement arrow.
derivedDelete :: TableDerivable r => RestrictedStatement r (PlaceHolders p) -> Delete p

-- | Arrow to build queries.
data QueryA m a b

-- | Arrow type corresponding to <a>QuerySimple</a>
type QuerySimple = QueryA QuerySimple

-- | Arrow type corresponding to <a>QueryAggregate</a>
type QueryAggregate = QueryA QueryAggregate

-- | Arrow type corresponding to <a>QueryUnique</a>
type QueryUnique = QueryA QueryUnique

-- | Arrow type corresponding to <a>AggregatingSet</a>
type AggregatingSet = QueryA AggregatingSet

-- | Arrow type corresponding to <a>AggregatingSetList</a>
type AggregatingSetList = QueryA AggregatingSetList

-- | Arrow type corresponding to <a>AggregatingPowerSet</a>
type AggregatingPowerSet = QueryA AggregatingPowerSet

-- | Arrow type corresponding to <a>Orderings</a>
type Orderings c m = QueryA (Orderings c m)

-- | Arrow type corresponding to <a>Window</a>
type Window c = QueryA (Window c)

-- | Arrow type corresponding to <a>Assignings</a>
type Assignings r m = QueryA (Assignings r m)

-- | Arrow type corresponding to <a>AssignStatement</a>
type AssignStatement r a = Assignings r Restrict (Record Flat r) a

-- | Arrow type corresponding to <a>Register</a>
type Register r a = QueryA (Register r) () a

-- | Arrow type corresponding to <a>RestrictedStatement</a>
type RestrictedStatement r a = QueryA Restrict (Record Flat r) a
instance GHC.Base.Monad m => Control.Arrow.Arrow (Database.Relational.Arrow.QueryA m)
instance GHC.Base.Monad m => Control.Category.Category (Database.Relational.Arrow.QueryA m)


-- | This module contains backword compatibility interface of
--   relational-query &lt;= 0.9.*

-- | <i>Deprecated: Should switch namespace to
--   Database.Relational.Arrow</i>
module Database.Relational.Query.Arrow
