-- 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:
--   
--   <ul>
--   <li>Type safe query building</li>
--   <li>Restriction, Join, Aggregation</li>
--   <li>Modularized relations</li>
--   <li>Typed placeholders</li>
--   </ul>
@package relational-query
@version 0.12.2.3


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

-- | Configuration type.
data Config

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

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

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

-- | <a>NameConfig</a> type to customize names of expanded templates.
data NameConfig

-- | Default implementation of <a>NameConfig</a> type.
defaultNameConfig :: NameConfig

-- | Default configuration of <a>Config</a>. To change some behaviour of
--   relational-query, use record update syntax:
--   
--   <pre>
--   defaultConfig
--     { productUnitSupport            =  <a>PUSupported</a>
--     , chunksInsertSize              =  256
--     , schemaNameMode                =  <a>SchemaQualified</a>
--     , normalizedTableName           =  True
--     , addQueryTableAliasAS          =  False
--     , addModifyTableAliasAS         =  False
--     , enableWarning                 =  True
--     , verboseAsCompilerWarning      =  False
--     , disableOverloadedProjection   =  False
--     , disableSpecializedProjection  =  False
--     , identifierQuotation           =  <a>NoQuotation</a>
--     , nameConfig                    =
--        defaultNameConfig
--        { recordConfig     =  <a>defaultNameConfig</a>
--        , relationVarName  =  \schema table -&gt; <a>varCamelcaseName</a> $ table ++ "_" ++ scheme
--        -- ^ append the table name after the schema name. e.g. "schemaTable"
--        }
--     }
--   </pre>
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

-- | Expand indexes from key.
expandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]

-- | Expand indexes from key. Infered width version.
expandIndexes :: PersistableWidth a => Pi a b -> [Int]

-- | <i>Deprecated: Use expandIndexes' instead of this.</i>
unsafeExpandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]

-- | <i>Deprecated: use expandIndexes instead of this.</i>
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

-- | Expand indexes from key.
expandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]

-- | Expand indexes from key. Infered width version.
expandIndexes :: PersistableWidth a => Pi a b -> [Int]


-- | 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>LiteralSQL</a> <tt>a</tt> is implicit rule to derive function to
--   convert from haskell record type <tt>a</tt> into SQL literal
--   row-value.
--   
--   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>LiteralSQL</a> class, so
--   you can make instance like below:
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   import GHC.Generics (Generic)
--   --
--   data Foo = Foo { ... } deriving Generic
--   instance LiteralSQL Foo
--   </pre>
class LiteralSQL a
showLiteral' :: LiteralSQL a => a -> DList StringSQL
showLiteral' :: (LiteralSQL a, Generic a, GLiteralSQL (Rep a)) => a -> DList StringSQL

-- | Convert from haskell record to SQL literal row-value.
showLiteral :: LiteralSQL a => a -> [StringSQL]

-- | String wrap type for SQL strings.
type StringSQL = Keyword

-- | Deprecated.

-- | <i>Deprecated: Use <a>LiteralSQL</a> instead of this.</i>
type ShowConstantTermsSQL = LiteralSQL

-- | <i>Deprecated: Use <a>showLiteral</a>` instead of this.</i>
showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL

-- | Deprecated.

-- | <i>Deprecated: Use <a>showLiteral</a> instead of this.</i>
showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL]
instance Database.Relational.ProjectableClass.ShowConstantTermsSQL a => Database.Relational.ProjectableClass.GLiteralSQL (GHC.Generics.K1 i a)
instance Database.Relational.ProjectableClass.GLiteralSQL GHC.Generics.U1
instance (Database.Relational.ProjectableClass.GLiteralSQL a, Database.Relational.ProjectableClass.GLiteralSQL b) => Database.Relational.ProjectableClass.GLiteralSQL (a GHC.Generics.:*: b)
instance Database.Relational.ProjectableClass.GLiteralSQL a => Database.Relational.ProjectableClass.GLiteralSQL (GHC.Generics.M1 i c a)

module Database.Relational.NonStandard.PureTimestampTZ
instance Database.Relational.ProjectableClass.LiteralSQL Data.Time.LocalTime.Internal.ZonedTime.ZonedTime
instance Database.Relational.ProjectableClass.LiteralSQL Data.Time.Clock.Internal.UTCTime.UTCTime


-- | This module defines instances which lift from haskell pure values to
--   query internal record values.
module Database.Relational.Pure
instance Database.Relational.ProjectableClass.LiteralSQL ()
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Int.Int8
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Int.Int16
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Int.Int32
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Int.Int64
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Int
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Word.Word8
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Word.Word16
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Word.Word32
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Word.Word64
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Word
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Integer.Type.Integer
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Base.String
instance Database.Relational.ProjectableClass.LiteralSQL Data.Text.Internal.Text
instance Database.Relational.ProjectableClass.LiteralSQL Data.Text.Internal.Lazy.Text
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Char
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Bool
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Float
instance Database.Relational.ProjectableClass.LiteralSQL GHC.Types.Double
instance Database.Relational.ProjectableClass.LiteralSQL Data.Time.Calendar.Days.Day
instance Database.Relational.ProjectableClass.LiteralSQL Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay
instance Database.Relational.ProjectableClass.LiteralSQL Data.Time.LocalTime.Internal.LocalTime.LocalTime
instance (Database.Record.Persistable.PersistableWidth a, Database.Relational.ProjectableClass.LiteralSQL a) => Database.Relational.ProjectableClass.LiteralSQL (GHC.Maybe.Maybe a)


-- | This module defines instances to lift from haskell UTF8 byte-sequence
--   to query internal record values. This module is not defaultly imported
--   to be selectable instance of byte-sequences.
module Database.Relational.PureUTF8
instance Database.Relational.ProjectableClass.LiteralSQL Data.ByteString.Internal.ByteString
instance Database.Relational.ProjectableClass.LiteralSQL Data.ByteString.Lazy.Internal.ByteString


-- | 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.Maybe.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 = Column

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

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

-- | 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 :: (Bool, Qualified SubQuery) -> 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, (Bool, 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

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

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

-- | Term of qualified table or qualified subquery, used in join-clause of
--   SELECT, correlated UPDATE and DELETE statements. When SubQuery is
--   table, expression will be like <a>TABLE</a> [AS] T<a>n</a>
corrSubQueryTerm :: Bool -> Qualified SubQuery -> StringSQL

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

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

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

-- | Compose ORDER BY clause from OrderingTerms
composeOrderBy :: [OrderingTerm] -> 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 a row of value expressions.
composeChunkValues :: Int -> [AssignTerm] -> Keyword

-- | Compose columns row and VALUES clause from a row of value expressions.
composeChunkValuesWithColumns :: Int -> [Assignment] -> StringSQL

-- | Compose columns row and VALUES clause from rows list of value
--   expressions.
composeValuesListWithColumns :: [[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

-- | <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
instance GHC.Show.Show (Database.Relational.Table.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.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2) => Database.Relational.ProjectableClass.LiteralSQL (a1, a2)
instance (Database.Relational.ProjectableClass.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2, Database.Relational.ProjectableClass.LiteralSQL a3) => Database.Relational.ProjectableClass.LiteralSQL (a1, a2, a3)
instance (Database.Relational.ProjectableClass.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2, Database.Relational.ProjectableClass.LiteralSQL a3, Database.Relational.ProjectableClass.LiteralSQL a4) => Database.Relational.ProjectableClass.LiteralSQL (a1, a2, a3, a4)
instance (Database.Relational.ProjectableClass.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2, Database.Relational.ProjectableClass.LiteralSQL a3, Database.Relational.ProjectableClass.LiteralSQL a4, Database.Relational.ProjectableClass.LiteralSQL a5) => Database.Relational.ProjectableClass.LiteralSQL (a1, a2, a3, a4, a5)
instance (Database.Relational.ProjectableClass.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2, Database.Relational.ProjectableClass.LiteralSQL a3, Database.Relational.ProjectableClass.LiteralSQL a4, Database.Relational.ProjectableClass.LiteralSQL a5, Database.Relational.ProjectableClass.LiteralSQL a6) => Database.Relational.ProjectableClass.LiteralSQL (a1, a2, a3, a4, a5, a6)
instance (Database.Relational.ProjectableClass.LiteralSQL a1, Database.Relational.ProjectableClass.LiteralSQL a2, Database.Relational.ProjectableClass.LiteralSQL a3, Database.Relational.ProjectableClass.LiteralSQL a4, Database.Relational.ProjectableClass.LiteralSQL a5, Database.Relational.ProjectableClass.LiteralSQL a6, Database.Relational.ProjectableClass.LiteralSQL a7) => Database.Relational.ProjectableClass.LiteralSQL (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 :: (LiteralSQL t, OperatorContext c) => t -> Record c t

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

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

-- | RecordList with polymorphic type of SQL set value from Haskell list.
values :: (LiteralSQL 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, LiteralSQL 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, LiteralSQL 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, 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 <a>(?!)</a>. Use this operator like '(? #foo) mayX'.
(?) :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
infixl 8 ?

-- | Same as <a>(?!?)</a>. 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, 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.Maybe.Maybe a) b => Database.Relational.Projectable.ProjectableFlattenMaybe (GHC.Maybe.Maybe (GHC.Maybe.Maybe a)) b
instance Database.Relational.Projectable.ProjectableFlattenMaybe (GHC.Maybe.Maybe a) (GHC.Maybe.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 "fst" (a1, a2) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2) => Database.Relational.OverloadedProjection.HasProjection "snd" (a1, a2) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2) => Database.Relational.OverloadedProjection.HasProjection "pi0" (a1, a2) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2) => Database.Relational.OverloadedProjection.HasProjection "pi1" (a1, a2) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "fst" (a1, a2, a3) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "snd" (a1, a2, a3) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "pi0" (a1, a2, a3) a1
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "pi1" (a1, a2, a3) a2
instance (Database.Record.Persistable.PersistableWidth a1, Database.Record.Persistable.PersistableWidth a2, Database.Record.Persistable.PersistableWidth a3) => Database.Relational.OverloadedProjection.HasProjection "pi2" (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 "fst" (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 "snd" (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 "pi0" (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 "pi1" (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 "pi2" (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 "pi3" (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 "fst" (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 "snd" (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 "pi0" (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 "pi1" (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 "pi2" (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 "pi3" (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 "pi4" (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 "fst" (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 "snd" (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 "pi0" (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 "pi1" (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 "pi2" (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 "pi3" (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 "pi4" (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 "pi5" (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 "fst" (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 "snd" (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 "pi0" (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 "pi1" (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 "pi2" (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 "pi3" (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 "pi4" (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 "pi5" (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 "pi6" (a1, a2, a3, a4, a5, a6, a7) a7


-- | 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 :: MonadQualify ConfigureQuery 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 [<a>Assignment</a>]
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>.
type Restriction p r = Record Flat r -> Restrict (PlaceHolders p)

-- | UpdateTarget type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p)

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all. With placefolder type <tt>p</tt>.
liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | 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> 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')

-- | DELETE statement with WHERE clause <a>StringSQL</a> string from
--   <a>Restrict</a> computation.
deleteFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL

-- | UPDATE statement with SET clause and WHERE clause <a>StringSQL</a>
--   string from <a>Assign</a> computation.
updateFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> 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

-- | Make <a>StringSQL</a> strings of SQL INSERT strings from records list
sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]

-- | Deprecated.

-- | <i>Deprecated: same as ((&gt;&gt; return unitPH) .)</i>
restriction :: (Record Flat r -> Restrict ()) -> Restriction () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r

-- | Deprecated.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.updateNoPH.</i>
updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all.

-- | <i>Deprecated: old-style API. use
--   Database.Relational.updateAllColumnNoPH instead of this.</i>
liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumnNoPH instead of
--   this.</i>
updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumn instead of
--   this.</i>
updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</a>.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.insertValueNoPH .</i>
insertTarget :: Register r () -> InsertTarget () r

-- | SQL WHERE clause <a>StringSQL</a> string from <a>Restrict</a>
--   computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL

-- | SQL SET clause and WHERE clause <a>StringSQL</a> string from
--   <a>Assign</a> computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL
instance Database.Relational.Table.TableDerivable r => GHC.Show.Show (Database.Relational.SqlSyntax.Types.Record Database.Relational.Internal.ContextType.Flat r -> Database.Relational.Monad.Restrict.Restrict (Database.Relational.Projectable.Unsafe.PlaceHolders p))
instance Database.Relational.Table.TableDerivable r => GHC.Show.Show (Database.Relational.SqlSyntax.Types.Record Database.Relational.Internal.ContextType.Flat r -> Database.Relational.Monad.Assign.Assign r (Database.Relational.Projectable.Unsafe.PlaceHolders p))


-- | 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_ :: Config -> Relation p r -> QuerySuffix -> Query p r

-- | 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>.
keyUpdate :: 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>Assign</a> computation.
typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Assign</a> computation.
update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation.
update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation with no(unit) placeholder.
updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update ()

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

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation. Update target is all column.
updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation. Update target is all column.
updateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation without placeholder other than target
--   table columns. Update target is all column.
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict ()) -> Update r

-- | Make untyped update SQL string from <a>Table</a> and <a>Assign</a>
--   computation.
updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> 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'

-- | Table type inferred <a>Insert</a>.
insert :: (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>Config</a>, derived table and monadic
--   builded <a>Register</a> object.
insertValue' :: 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.
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Make typed <a>Insert</a> from <a>defaultConfig</a>, derived table and
--   monadic builded <a>Register</a> object with no(unit) placeholder.
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()

-- | Make typed <a>Insert</a> list from <a>Config</a> and records list.
insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]

-- | Make typed <a>Insert</a> list from records list.
insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]

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

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

-- | Table type inferred <a>InsertQuery</a> with <a>defaultConfig</a>.
insertQuery :: 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>Restrict</a> computation.
typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation.
delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation.
delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation with no(unit) placeholder.
deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete ()

-- | Make untyped delete SQL string from <a>Table</a> and <a>Restrict</a>
--   computation.
deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> 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

-- | Make typed <a>Update</a> using <a>defaultConfig</a>, <a>Table</a> and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>typedUpdate</a> defaultConfig` instead of
--   this.</i>
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Insert</a> from <a>Table</a> and columns selector
--   <a>Pi</a>.

-- | <i>Deprecated: use <a>typedInsert</a> defaultConfig` instead of
--   this.</i>
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'

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

-- | <i>Deprecated: use <a>typedInsertValue</a> defaultConfig` instead of
--   this.</i>
typedInsertValue :: Table r -> InsertTarget p r -> Insert p

-- | Make typed <a>InsertQuery</a> from columns selector <a>Table</a>,
--   <a>Pi</a> and <a>Relation</a>.

-- | <i>Deprecated: use <a>typedInsertQuery</a> defaultConfig` instead of
--   this.</i>
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p

-- | Make typed <a>Delete</a> from <a>Table</a> and <a>Restrict</a>
--   computation.

-- | <i>Deprecated: use <a>typedDelete</a> defaultConfig` instead of
--   this.</i>
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>KeyUpdate</a> from derived table and key columns
--   selector <a>Pi</a>.

-- | <i>Deprecated: use keyUpdate instead of this.</i>
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>update</a>` instead of this.</i>
derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>update</a> instead of this.</i>
derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Deprecated. use <a>updateAllColumn'</a>.

-- | <i>Deprecated: use <a>updateAllColumn</a>` instead of this.</i>
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

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

-- | <i>Deprecated: use <a>updateAllColumn</a> instead of this.</i>
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Table type inferred <a>Insert</a>.

-- | <i>Deprecated: use <a>insert</a> instead of this.</i>
derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'

-- | Make typed <a>Insert</a> from <a>Config</a>, derived table and monadic
--   builded <a>Register</a> object.

-- | <i>Deprecated: use <a>insertValue</a>` instead of this.</i>
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.

-- | <i>Deprecated: use <a>insertValue</a> instead of this.</i>
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Table type inferred <a>InsertQuery</a>.

-- | <i>Deprecated: use <a>insertQuery</a> instead of this.</i>
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

-- | Make typed <a>Delete</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation.

-- | <i>Deprecated: use <a>delete</a>` instead of this.</i>
derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation.

-- | <i>Deprecated: use <a>delete</a> instead of this.</i>
derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
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. actual sequence-table is a
--   table which has only one column of integer type.
data Sequence s i

-- | actual sequence-table
seqTable :: Sequence s i -> Table s

-- | sequence number selector for sequence record
seqExtract :: Sequence s i -> s -> i

-- | sequence number projection for sequence record
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

-- | Record to express binding between normal-table and sequence-table.
data SeqBinding r s i

-- | normal-table bound to sequence-table
boundTable :: SeqBinding r s i -> Table r

-- | sequence key projection for bound record
boundKey :: SeqBinding r s i -> Pi r i

-- | sequence table record
boundSequence :: SeqBinding r s i -> Sequence s i

-- | Unsafely specify binding between normal-table and sequence-table.
unsafeSpecifyBinding :: (TableDerivable r, SequenceDerivable s i) => Pi r i -> SeqBinding r s i

-- | Derive binding using primary key.
primaryBinding :: (TableDerivable r, SequenceDerivable s i, HasConstraintKey Primary r i) => SeqBinding r 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
binding :: Binding r s i => SeqBinding r s i
binding :: (Binding r s i, HasConstraintKey Primary r i) => SeqBinding r 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, LiteralSQL i) => Config -> i -> Sequence s i -> Update ()

-- | Update statement for sequence table
updateNumber :: (PersistableWidth s, Integral i, LiteralSQL 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.
uniqueSelect :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a

-- | Query restricted with inferred primary key.
primarySelect :: 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

-- | Deprecated.

-- | <i>Deprecated: use <a>uniqueSelect</a> instead of this.</i>
unique :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a

-- | Deprecated.

-- | <i>Deprecated: use <a>primarySelect</a> instead of this.</i>
primary' :: PersistableWidth p => Key Primary a p -> Relation () a -> Relation p a

-- | Deprecated.

-- | <i>Deprecated: use <a>primarySelect</a> instead of this.</i>
primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a


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

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

-- | Phantom typed table type
data Table r

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

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

-- | Constraint type. Unique key.
data Unique

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

-- | Constraint type. Primary key.
data Primary

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

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

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

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

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

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

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

-- | Sub-query type
data SubQuery

-- | Typeful aggregate element.
data AggregateKey a

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

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

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

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

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

-- | 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 ()

-- | 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)

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

-- | Query building interface.
class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery 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))

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

-- | Add restriction to this context.
restrict :: MonadRestrict c m => Predicate c -> 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 ()

-- | Type to accumulate ordering context. Type <tt>c</tt> is ordering term
--   record context type.
data 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 ()

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

-- | 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 <-#

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

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

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

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

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

-- | 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`

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

-- | Unique query monad type.
data QueryUnique a

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

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

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

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

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

-- | InsertQuery type.
newtype InsertQuery p
InsertQuery :: String -> InsertQuery p
[untypeInsertQuery] :: InsertQuery p -> 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)

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

-- | 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 untyped SQL query string.
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String

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

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

-- | 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>.
keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

-- | Make typed <a>KeyUpdate</a> from derived table and key columns
--   selector <a>Pi</a>.

-- | <i>Deprecated: use keyUpdate instead of this.</i>
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

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

-- | Make untyped update SQL string from <a>Table</a> and <a>Assign</a>
--   computation.
updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String

-- | Make typed <a>Update</a> from <a>Config</a>, <a>Table</a> and
--   <a>Assign</a> computation.
typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> using <a>defaultConfig</a>, <a>Table</a> and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>typedUpdate</a> defaultConfig` instead of
--   this.</i>
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Assign</a> computation.
update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>update</a>` instead of this.</i>
derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation.
update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation with no(unit) placeholder.
updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update ()

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>update</a> instead of this.</i>
derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

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

-- | Make typed <a>Update</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation. Update target is all column.
updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Deprecated. use <a>updateAllColumn'</a>.

-- | <i>Deprecated: use <a>updateAllColumn</a>` instead of this.</i>
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation. Update target is all column.
updateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

-- | Make typed <a>Update</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation without placeholder other than target
--   table columns. Update target is all column.
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict ()) -> Update r

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

-- | <i>Deprecated: use <a>updateAllColumn</a> instead of this.</i>
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

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

-- | 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>.

-- | <i>Deprecated: use <a>typedInsert</a> defaultConfig` instead of
--   this.</i>
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'

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

-- | Table type inferred <a>Insert</a>.

-- | <i>Deprecated: use <a>insert</a> instead of this.</i>
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.

-- | <i>Deprecated: use <a>typedInsertValue</a> defaultConfig` instead of
--   this.</i>
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.
insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

-- | Make typed <a>Insert</a> from <a>Config</a>, derived table and monadic
--   builded <a>Register</a> object.

-- | <i>Deprecated: use <a>insertValue</a>` instead of this.</i>
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.
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Make typed <a>Insert</a> from <a>defaultConfig</a>, derived table and
--   monadic builded <a>Register</a> object with no(unit) placeholder.
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()

-- | Make typed <a>Insert</a> from <a>defaultConfig</a>, derived table and
--   monadic builded <a>Register</a> object.

-- | <i>Deprecated: use <a>insertValue</a> instead of this.</i>
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Make typed <a>Insert</a> list from <a>Config</a> and records list.
insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]

-- | Make typed <a>Insert</a> list from records list.
insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]

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

-- | 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>.

-- | <i>Deprecated: use <a>typedInsertQuery</a> defaultConfig` instead of
--   this.</i>
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p

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

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

-- | Table type inferred <a>InsertQuery</a>.

-- | <i>Deprecated: use <a>insertQuery</a> instead of this.</i>
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

-- | Make untyped delete SQL string from <a>Table</a> and <a>Restrict</a>
--   computation.
deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String

-- | Make typed <a>Delete</a> from <a>Config</a>, <a>Table</a> and
--   <a>Restrict</a> computation.
typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>Table</a> and <a>Restrict</a>
--   computation.

-- | <i>Deprecated: use <a>typedDelete</a> defaultConfig` instead of
--   this.</i>
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation.
delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>Config</a>, derived table and
--   <a>Restrict</a> computation.

-- | <i>Deprecated: use <a>delete</a>` instead of this.</i>
derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation.
delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation with no(unit) placeholder.
deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete ()

-- | Make typed <a>Delete</a> from <a>defaultConfig</a>, derived table and
--   <a>Restrict</a> computation.

-- | <i>Deprecated: use <a>delete</a> instead of this.</i>
derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

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

-- | UpdateTarget type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p)

-- | Restriction type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
type Restriction p r = Record Flat r -> Restrict (PlaceHolders p)

-- | Deprecated.

-- | <i>Deprecated: same as ((&gt;&gt; return unitPH) .)</i>
restriction :: (Record Flat r -> Restrict ()) -> Restriction () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r

-- | SQL WHERE clause <a>StringSQL</a> string from <a>Restrict</a>
--   computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL

-- | Deprecated.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.updateNoPH.</i>
updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all.

-- | <i>Deprecated: old-style API. use
--   Database.Relational.updateAllColumnNoPH instead of this.</i>
liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all. With placefolder type <tt>p</tt>.
liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumnNoPH instead of
--   this.</i>
updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumn instead of
--   this.</i>
updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | SQL SET clause and WHERE clause <a>StringSQL</a> string from
--   <a>Assign</a> computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</a>.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.insertValueNoPH .</i>
insertTarget :: Register r () -> InsertTarget () r

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</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')

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

-- | Make <a>StringSQL</a> strings of SQL INSERT strings from records list
sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]


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

-- | Constraint type. Unique key.
data Unique

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

-- | Constraint type. Primary key.
data Primary

-- | Configuration type.
data Config

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

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

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

-- | <a>NameConfig</a> type to customize names of expanded templates.
data NameConfig

-- | Default implementation of <a>NameConfig</a> type.
defaultNameConfig :: NameConfig

-- | Default configuration of <a>Config</a>. To change some behaviour of
--   relational-query, use record update syntax:
--   
--   <pre>
--   defaultConfig
--     { productUnitSupport            =  <a>PUSupported</a>
--     , chunksInsertSize              =  256
--     , schemaNameMode                =  <a>SchemaQualified</a>
--     , normalizedTableName           =  True
--     , addQueryTableAliasAS          =  False
--     , addModifyTableAliasAS         =  False
--     , enableWarning                 =  True
--     , verboseAsCompilerWarning      =  False
--     , disableOverloadedProjection   =  False
--     , disableSpecializedProjection  =  False
--     , identifierQuotation           =  <a>NoQuotation</a>
--     , nameConfig                    =
--        defaultNameConfig
--        { recordConfig     =  <a>defaultNameConfig</a>
--        , relationVarName  =  \schema table -&gt; <a>varCamelcaseName</a> $ table ++ "_" ++ scheme
--        -- ^ append the table name after the schema name. e.g. "schemaTable"
--        }
--     }
--   </pre>
defaultConfig :: Config

-- | Type tag for aggregatings power set
data Power

-- | Type tag for aggregatings GROUPING SETS
data SetList

-- | Type tag for normal aggregatings set
data Set

-- | Type tag for window function building
data OverWindow

-- | Type tag for exists predicate
data Exists

-- | Type tag for aggregated query
data Aggregated

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

-- | String wrap type for SQL strings.
type StringSQL = Keyword

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

-- | Expand indexes from key.
expandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]

-- | Expand indexes from key. Infered width version.
expandIndexes :: PersistableWidth a => Pi a b -> [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 <?.?>

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

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

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

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

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

-- | Deprecated.

-- | <i>Deprecated: Use <a>LiteralSQL</a> instead of this.</i>
type ShowConstantTermsSQL = LiteralSQL

-- | <a>LiteralSQL</a> <tt>a</tt> is implicit rule to derive function to
--   convert from haskell record type <tt>a</tt> into SQL literal
--   row-value.
--   
--   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>LiteralSQL</a> class, so
--   you can make instance like below:
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   import GHC.Generics (Generic)
--   --
--   data Foo = Foo { ... } deriving Generic
--   instance LiteralSQL Foo
--   </pre>
class LiteralSQL a
showLiteral' :: LiteralSQL a => a -> DList StringSQL
showLiteral' :: (LiteralSQL a, Generic a, GLiteralSQL (Rep a)) => a -> DList StringSQL

-- | Convert from haskell record to SQL literal row-value.
showLiteral :: LiteralSQL a => a -> [StringSQL]

-- | <i>Deprecated: Use <a>showLiteral</a>` instead of this.</i>
showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL

-- | Deprecated.

-- | <i>Deprecated: Use <a>showLiteral</a> instead of this.</i>
showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL]

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

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

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

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

-- | Sub-query type
data SubQuery

-- | Typeful aggregate element.
data AggregateKey a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Phantom typed table type
data Table r

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

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

-- | Generate update SQL specified by single key.
updateOtherThanKeySQL :: Table r -> Pi r p -> String
tuplePi2_0' :: forall a1 a2. (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a1
tuplePi2_1' :: forall a1 a2. (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a2
tuplePi3_0' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a1
tuplePi3_1' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a2
tuplePi3_2' :: forall a1 a2 a3. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a3
tuplePi4_0' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a1
tuplePi4_1' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a2
tuplePi4_2' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a3
tuplePi4_3' :: forall a1 a2 a3 a4. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a4
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
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_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_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_4' :: forall a1 a2 a3 a4 a5. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a5
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
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_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_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_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_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
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
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_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_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_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_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_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

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

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

-- | 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)

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

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

-- | 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)

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

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

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

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

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

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

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

-- | 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'`

-- | 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)

-- | 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) => 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'`

-- | String-compare operator corresponding SQL <i>LIKE</i> .
like :: (OperatorContext c, IsString a, LiteralSQL 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, LiteralSQL a) => Record c (Maybe a) -> 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 /// .
(./.) :: (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 a -> Record c a -> Record c a
infixl 7 .*.

-- | 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 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 /// .
(?/?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe 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 7 ?*?

-- | 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)

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

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

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

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

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

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

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

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

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

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

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

-- | 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)

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

-- | 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.
sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)

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

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

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

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

-- | Aggregation function MAX.
max' :: (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 MIN.
min' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat 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)

-- | Get narrower record along with projection path.
(!) :: PersistableWidth a => Record c a -> Pi a b -> Record c 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.
flattenPiMaybe :: (PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) => Record cont (Maybe a) -> Pi a b -> Record cont c

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

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

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

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

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

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

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

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

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

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

-- | 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)

-- | 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)

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

-- | 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 update monad type used from update statement and merge
--   statement.
type Assign r = Assignings r Restrict

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

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

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

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

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

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

-- | 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`

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

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

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

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

-- | 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'`

-- | 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.
except' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 7 `except'`

-- | 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.
intersect' :: Relation p a -> Relation q a -> Relation (p, q) a
infixl 8 `intersect'`

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

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

-- | UpdateTarget type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p)

-- | Restriction type with place-holder parameter <tt>p</tt> and projected
--   record type <tt>r</tt>.
type Restriction p r = Record Flat r -> Restrict (PlaceHolders p)

-- | Deprecated.

-- | <i>Deprecated: same as ((&gt;&gt; return unitPH) .)</i>
restriction :: (Record Flat r -> Restrict ()) -> Restriction () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r

-- | SQL WHERE clause <a>StringSQL</a> string from <a>Restrict</a>
--   computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL

-- | Deprecated.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.updateNoPH.</i>
updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r

-- | Deprecated.

-- | <i>Deprecated: same as id</i>
updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all.

-- | <i>Deprecated: old-style API. use
--   Database.Relational.updateAllColumnNoPH instead of this.</i>
liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Lift <a>Restrict</a> computation to <a>Assign</a> computation. Assign
--   target columns are all. With placefolder type <tt>p</tt>.
liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumnNoPH instead of
--   this.</i>
updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r)

-- | Deprecated.

-- | <i>Deprecated: Use Database.Relational.updateAllColumn instead of
--   this.</i>
updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

-- | SQL SET clause and WHERE clause <a>StringSQL</a> string from
--   <a>Assign</a> computation.

-- | <i>Deprecated: low-level API, this API will be expired.</i>
sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</a>.

-- | <i>Deprecated: old-style API. Use new-style
--   Database.Relational.insertValueNoPH .</i>
insertTarget :: Register r () -> InsertTarget () r

-- | Finalize <a>Register</a> monad and generate <a>InsertTarget</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')

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

-- | Make <a>StringSQL</a> strings of SQL INSERT strings from records list
sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]

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

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

-- | InsertQuery type.
newtype InsertQuery p
InsertQuery :: String -> InsertQuery p
[untypeInsertQuery] :: InsertQuery p -> 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)

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

-- | 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 untyped SQL query string.
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String

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

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

-- | 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>.
keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

-- | Make typed <a>KeyUpdate</a> from derived table and key columns
--   selector <a>Pi</a>.

-- | <i>Deprecated: use keyUpdate instead of this.</i>
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

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

-- | Make untyped update SQL string from <a>Table</a> and <a>Assign</a>
--   computation.
updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String

-- | Make typed <a>Update</a> from <a>Config</a>, <a>Table</a> and
--   <a>Assign</a> computation.
typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

-- | Make typed <a>Update</a> using <a>defaultConfig</a>, <a>Table</a> and
--   <a>Assign</a> computation.

-- | <i>Deprecated: use <a>typedUpdate</a> defaultConfig` instead of
--   this.</i>
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

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

-- | Deprecated. use <a>updateAllColumn'</a>.

-- | <i>Deprecated: use <a>updateAllColumn</a>` instead of this.</i>
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

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

-- | <i>Deprecated: use <a>updateAllColumn</a> instead of this.</i>
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

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

-- | 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>.

-- | <i>Deprecated: use <a>typedInsert</a> defaultConfig` instead of
--   this.</i>
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'

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

-- | Table type inferred <a>Insert</a>.

-- | <i>Deprecated: use <a>insert</a> instead of this.</i>
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.

-- | <i>Deprecated: use <a>typedInsertValue</a> defaultConfig` instead of
--   this.</i>
typedInsertValue :: Table r -> InsertTarget p r -> Insert p

-- | Make typed <a>Insert</a> list from <a>Config</a> and records list.
insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]

-- | Make typed <a>Insert</a> list from records list.
insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]

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

-- | 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>.

-- | <i>Deprecated: use <a>typedInsertQuery</a> defaultConfig` instead of
--   this.</i>
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p

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

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

-- | Table type inferred <a>InsertQuery</a>.

-- | <i>Deprecated: use <a>insertQuery</a> instead of this.</i>
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

-- | Make untyped delete SQL string from <a>Table</a> and <a>Restrict</a>
--   computation.
deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String

-- | Make typed <a>Delete</a> from <a>Config</a>, <a>Table</a> and
--   <a>Restrict</a> computation.
typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Make typed <a>Delete</a> from <a>Table</a> and <a>Restrict</a>
--   computation.

-- | <i>Deprecated: use <a>typedDelete</a> defaultConfig` instead of
--   this.</i>
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

-- | Sequence number type for record type <tt>r</tt>
data Number r 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
binding :: Binding r s i => SeqBinding r s i
binding :: (Binding r s i, HasConstraintKey Primary r i) => SeqBinding r s i

-- | Record to express binding between normal-table and sequence-table.
data SeqBinding r s i

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

-- | Basic record to express sequence-table. actual sequence-table is a
--   table which has only one column of integer type.
data Sequence s i

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

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

-- | Unsafely specify binding between normal-table and sequence-table.
unsafeSpecifyBinding :: (TableDerivable r, SequenceDerivable s i) => Pi r i -> SeqBinding r s i

-- | Derive binding using primary key.
primaryBinding :: (TableDerivable r, SequenceDerivable s i, HasConstraintKey Primary r i) => SeqBinding r s i

-- | Derive <a>Sequence</a> from corresponding <a>Relation</a>
fromRelation :: Binding r s i => Relation () r -> Sequence s 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, LiteralSQL i) => Config -> i -> Sequence s i -> Update ()

-- | Update statement for sequence table
updateNumber :: (PersistableWidth s, Integral i, LiteralSQL i) => i -> Sequence s i -> Update ()

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

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

-- | Deprecated.

-- | <i>Deprecated: use <a>uniqueSelect</a> instead of this.</i>
unique :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a

-- | Deprecated.

-- | <i>Deprecated: use <a>primarySelect</a> instead of this.</i>
primary' :: PersistableWidth p => Key Primary a p -> Relation () a -> Relation p a

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

-- | Deprecated.

-- | <i>Deprecated: use <a>primarySelect</a> instead of this.</i>
primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a

-- | 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]

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

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

-- | 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>update'</a>. Make <a>Update</a> from assigning statement
--   arrow using configuration.
update' :: TableDerivable r => Config -> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p

-- | Same as <a>update</a>. Make <a>Update</a> from assigning statement
--   arrow.
update :: TableDerivable r => QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p

-- | Same as <a>updateNoPH</a>. Make <a>Update</a> from assigning statement
--   arrow.
updateNoPH :: TableDerivable r => QueryA (Assignings r Restrict) (Record Flat r) () -> Update ()

-- | Same as <a>updateAllColumn'</a>. Make <a>Update</a> from restrected
--   statement arrow.
updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Update (r, p)

-- | Same as <a>updateAllColumn</a>. Make <a>Update</a> from restrected
--   statement arrow.
updateAllColumn :: (PersistableWidth r, TableDerivable r) => QueryA Restrict (Record Flat r) (PlaceHolders p) -> Update (r, p)

-- | Same as <a>updateAllColumnNoPH</a>. Make <a>Update</a> from restrected
--   statement arrow.
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => QueryA Restrict (Record Flat r) () -> Update r

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

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

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

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

-- | Same as <a>delete</a>. Make <a>Update</a> from restrict statement
--   arrow.
delete :: TableDerivable r => QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p

-- | Same as <a>deleteNoPH</a>. Make <a>Update</a> from restrict statement
--   arrow.
deleteNoPH :: TableDerivable r => QueryA Restrict (Record Flat r) () -> Delete ()

-- | 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 = QueryA (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

-- | Same as <a>update'</a>. Make <a>Update</a> from assigning statement
--   arrow using configuration.

-- | <i>Deprecated: use <a>update</a>` instead of this.</i>
derivedUpdate' :: TableDerivable r => Config -> QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p

-- | Deprecated.

-- | <i>Deprecated: use <a>update</a> instead of this.</i>
derivedUpdate :: TableDerivable r => QueryA (Assignings r Restrict) (Record Flat r) (PlaceHolders p) -> Update p

-- | Deprecated.

-- | <i>Deprecated: use <a>insertValue</a>` instead of this.</i>
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

-- | Deprecated.

-- | <i>Deprecated: use <a>insertValue</a> instead of this.</i>
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

-- | Deprecated.

-- | <i>Deprecated: use <a>derivedDelete</a>` instead of this.</i>
derivedDelete' :: TableDerivable r => Config -> QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p

-- | Deprecated.

-- | <i>Deprecated: use <a>derivedDelete</a> instead of this.</i>
derivedDelete :: TableDerivable r => QueryA Restrict (Record Flat r) (PlaceHolders p) -> Delete p
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)
