!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI J K L M N O P Q R S T U V W XYZ[\]^_`a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !!!!!!!!!!!!!!!!!!!!!!&"unknown experimentalex8k.hibino@gmail.com Safe-Inferred"String wrap type for SQL strings.  from  .   to  .  Row String of SQL values.   Place holder row String of SQL.  Rows String of SQL. )Rows String of SQL. String type version.             unknown experimentalex8k.hibino@gmail.com Safe-InferredBPhantom typed SQL expression object. Project from projection type p. &Get SQL expression from typed object. "Get SQL string from typed object. Show expression. unknown experimentalex8k.hibino@gmail.comNone+Constraint which represents scalar degree.  instance templates. unknown experimentalex8k.hibino@gmail.com Safe-Inferred $Type tag for aggregatings power set (Type tag for aggregatings GROUPING SETS %Type tag for normal aggregatings set &Type tag for window function building Type tag for exists predicate Type tag for aggregated query )Type tag for flat (not-aggregated) query     unknown experimentalex8k.hibino@gmail.comNone&Interface for constant SQL term list. CSpecify tuple like record constructors which are allowed to define ProjectableFunctor. The constructor which has type r. "Constant integral SQL expression. Escape  % for constant SQL string expression. From  & into constant SQL string expression. Constant SQL terms of '(a, b)' type. Constant SQL terms of $ type. Width inference is required. Constant SQL terms of . Constant SQL terms of . Constant SQL terms of . Constant SQL terms of ). Caution for floating-point error rate. Constant SQL terms of  ). Caution for floating-point error rate. !Constant SQL terms of ". #Constant SQL terms of $. %Constant SQL terms of &. 'Constant SQL terms of (. )Constant SQL terms of *. +Constant SQL terms of ,. -Constant SQL terms of  . .Constant SQL terms of /. 0Constant SQL terms of 1. 2Constant SQL terms of 3. 4%ProductConstructor instance of pair. 56789!#%')+-.02456789!#%')+-.024unknown experimentalex8k.hibino@gmail.comNone2Typed constant SQL expression from Haskell value. :Unsafely cast phantom type. Convert phantom type into . !Allowed only for having or where . / So NULL expression result will be possible. K Behavior around boolean is strongly dependent on RDBMS impelemetations. AND operator for . ::unknown experimentalex8k.hibino@gmail.comNone'Assignment pair list. Assignment pair Value SQL String Column SQL String Type for order-by terms Type for order-by term Type for order-by column *Order direction. Ascendant or Descendant. "Type for group-by tree #Type for grouping set $Type for group key. %Type for group-by term &Type for restriction of query. '$Result record duplication attribute *%Unit of product is supported or not. -Configuration type. 1Column SQL string type ;Simple wrap type 21 from string 31 from  <String from ColumnSQL 4StringSQL from ColumnSQL 5Default configuration. 6&Compose duplication attribute string. =Compose SQL String from &. 7Compose WHERE clause from &. 8Compose HAVING clause from &. 9!Single term aggregation element. :Key of aggregation power set. ;Single grouping set. <Rollup aggregation element. =Cube aggregation element. >Grouping sets aggregation. ?Empty aggregation. @1Compose GROUP BY clause from AggregateElem list. A:Compose PARTITION BY clause from AggregateColumnRef list. B+Compose ORDER BY clause from OrderingTerms CCompose SET clause from . DCompose OVER (PARTITION BY ... ) clause. > !">?@A#B$C%&'()*+,-D./01;E23<456=789:;<=>?FGHI@ABCDJK- !"#$%&'()*+,-./0123456789:;<=>?@ABCD-1234-./05*,+')(6&78%$#"9?:;<=>@A! BCD-! "A@?>#B$C%&')(*,+-D./01;E23<456=789:;<=>?FGHI@ABCDJKunknown experimentalex8k.hibino@gmail.comNoneEL/ type to require query generate configuration. FRun E to expand with configuration GLift to E. HRead configuration. EMFGHEFGHEGFHEMFGH#unknown experimentalex8k.hibino@gmail.comNone N/Product node. node attribute and product tree. OLProduct tree type. Product tree is constructed by left node and right node. Pnode attribute for product. QGet node attribute. RGet tree from node. S8Make product node from node attribute and product tree. T'Push new tree into product right term. U,Push new leaf node into product right term. VJust make product of two node. W2Add restriction into top product of product tree. X7Add restriction into top product of product tree node. Y!Foldable instance of ProductTree NZO[\P]^_QRSNode attribute  Product tree  Result node T Current tree New tree to push into right  Result node U Current tree New leaf to push into right  Result node V Left node  Right node Join restriction  Result tree WProduct to restrict Restriction to add Result product X*Target node which has product to restrict Restriction to add  Result node YNO[\P]^QRSTUVX NZO\[P^]_QRSTUVWXY unknown experimentalex8k.hibino@gmail.comNoneIProjection path from type r0 into type r1. 4 This type also indicate key object which type is r1 for record type r0. `(Projection path primary structure type. J'Unsafely untype key to expand indexes. aNUnsafely cast width proof object of record. Result record must be same width. KProjectable fmap of I type. LProjectable ap of I type. bGet record width proof object. MGet record width. NCompose projection path. OCompose projection path.  phantom functor is c-ed. PCompose projection path.  phantom functors are join -ed like >=>. Q%Unsafely project untyped value list. d*Unsafely define projection path from type r0 into type r1. R*Unsafely define projection path from type r0 into type r1.  Use infered e. S*Unsafely define projection path from type r0 into type r1. T*Unsafely define projection path from type r0 into type r1.  Use infered e. If`ghijJakKLbMNOPQdIndex of flat SQL value list Result projection path RIndex of flat SQL value list Result projection path SIndexes of flat SQL value list Result projection path TIndexes of flat SQL value list Result projection path IJKLMNOPQRST IKLMNOPQRSTJIf`hgijJakKLbMNOPQdRST unknown experimentalex8k.hibino@gmail.comNoneUIdentity projection path. V"Projection path for fst of tuple. W"Projection path for snd of tuple. UVProjection path of fst. lWProjection path of snd. IKLNOPUVW IKLNOPUVWUVlWunknown experimentalex8k.hibino@gmail.comNone X Constraint Z inference interface. YInfer constraint key. Z-Constraint Key proof object. Constraint type c, record type r and columns type ct. [-Index of key which specifies constraint key. mWidth of key. \Unsafely generate constraint Z) proof object using specified key index. ]Get table constraint n proof object from constraint Z. ^1Get projection path proof object from constraint Z. o7Unsafe. Make constraint key to add column phantom type p*Map from table constraint into constraint Z. _Derive  constraint Z from  constraint Z `Infered  constraint Z.  Record type r has unique key which type is ct derived from primay key. XYZq[m\.Key indexes which specify this constraint key #Result constraint key proof object ]^op_` XYZ[\]^_` Z[\]^_XY` XYZq[m\]^op_` unknown experimentalex8k.hibino@gmail.comNoneaInference rule of c existence. cPhantom typed table type dUntyped typed table type eName string of table in SQL fWidth of table rColumn name strings in SQL gColumn name strings in SQL h-Column name string in SQL specified by index iUntype table. jName string of table in SQL k*Not qualified name string of table in SQL lWidth of table mColumn name strings in SQL n-Column name string in SQL specified by index oCast phantom type into  type. p,Unsafely generate phantom typed table type. abcsdtefrgh Column index Column name String in SQL ijklmn Column index Column name String in SQL opabcdefghijklmnopdefghcijklmnpoababcsdtefrghijklmnop unknown experimentalex8k.hibino@gmail.comNone+q Type for join product of query. rProduct node specialized by y. sProduct tree specialized by y. t(Untyped projection. Forgot record type. uProjection structure unit vQualified query. wQualifier type. ySub-query type zy from c. {Unsafely generate flat y from untyped components. |Unsafely generate aggregated y from untyped components. }Union binary operator on y ~Except binary operator on y Intersect binary operator on y  Width of y. uSQL to query table. v+Generate normalized column SQL from table. wNormalized column SQL x.SQL string for nested-query and toplevel-SQL. SQL string for nested-qeury.  SQL StringSQL for toplevel-SQL. SQL string for toplevel-SQL. Get qualifier  Unqualify. Add qualifier yAlias string from qualifier zBinary operator to qualify. {:Qualified expression from qualifier and projection index. |From v SQL string into  .  Width of v SubQUery. Get column SQL string of y. }2Get qualified SQL string, like (SELECT ...) AS T0 &Make untyped projection from columns. /Make untyped projection from scalar sub-query. /Make untyped projection from joined sub-query. ~ProjectionUnit width. Get column of ProjectionUnit.  Width of t. Get column SQL string of t. *Get column SQL string list of projection. 7Show product tree of query into SQL. StringSQL result. Shows join product of query.  instance of v DqrstuvwxyzTyped c metadata Result y {|}~uvwxsubquery SQL and top-level SQL yz{|}~Source  Projection  Column index Result SQL string Source  Projection Result SQL string list qrstuvwxyz{|}~yz{|}~wxvutsrq7qrstuvwxyz{|}~uvwxyz{|}~$unknown experimentalex8k.hibino@gmail.comNone JoinContext type for QueryJoin. Initial . Update product of . Update product of . 7Finalize context to extract accumulated query product. %unknown experimentalex8k.hibino@gmail.comNone'Monad type to qualify SQL table forms. 9Run qualify monad with initial state to get only result. +Generated new qualifier on internal state. Lift to   Get qualifyed table form query. Query to qualify Result with updated state  unknown experimentalex8k.hibino@gmail.comNoneProjection type for row list. =Phantom typed projection. Projected into Haskell record type t.  Width of . *Get column SQL string list of projection. !Unsafely get untyped projection. Unsafely generate  from SQL string list. Unsafely generate # from qualified (joined) subquery. Unsafely generate  from scalar subquery. Unsafely generate unqualified  from c. Lift  to  to use as restrict predicate.  Unsafely trace projection path. &Trace projection path to get narrower . &Trace projection path to get narrower . From  type to  type. &Trace projection path to get narrower . From  type to  type. # Leaf type of projection path is . Composite nested  on projection phantom type.  Cast into  on projection phantom type.  Unsafely cast context type tag. %Unsafely lift to aggregated context. Unsafely down to flat context. ?Unsafely get SQL string expression of not null key projection. Projectable fmap of  type. Projectable ap of  type. Make row list projection from  list. Make row list projection from y. JMap projection show operatoions and concatinate to single SQL expression. Source  Result SQL string list "SQL string list specifies columns Result  Source  Projection path  Narrower  Source .  type Projection path  Narrower .  type result Source .  type Projection path.  type leaf  Narrower .  type result unknown experimentalex8k.hibino@gmail.comNone Type for query suffix words Expand query suffix words &Generate prefix string of update SQL. 0Generate update SQL by specified key and table. 1 Columns name list of table are also required. 0Generate update SQL by specified key and table. 1 Columns name list of table are also required. -Generate update SQL specified by single key. &Generate prefix string of insert SQL. #Generate records chunk insert SQL. 1Generate size measured records chunk insert SQL. Generate insert SQL. JGenerate all column delete SQL by specified table. Untyped table version. 3Generate all column delete SQL by specified table.  Table name Column name list to update Key column name list  Result SQL  Table name Column name list Key column indexes  Result SQL Table metadata  Key columns  Result SQL Records count to insert Columns selector to insert Table metadata  Result SQL Columns selector to insert Table metadata $Chunk size threshold (column count) &Result SQL and records count of chunk Columns selector to insert Table metadata  Result SQL Table metadata  Result SQL unknown experimentalex8k.hibino@gmail.comNonee+Weaken applicative functor on projections.  Method like <*>. Weaken functor on projections.  Method like . *Zipping except for identity element laws. Interface to control ! of phantom type in projections. "Cast projection phantom type into . Compose nested  phantom type on projection. BPlaceholder parameter type which has real parameter type arguemnt p. %Binary operator type for SQL String. ,Interface to get SQL term from projections. @Unsafely generate SQL expression string from projection object. )Interface to project SQL terms unsafely. .Unsafely project from SQL expression strings. Unsafely get SQL term from  Proejction.  from  3Project from Projection type into expression type. Unsafely generate  from SQL expression strings. "Unsafely Project single SQL term. *Polymorphic projection of SQL null value. KGenerate polymorphic projection of SQL constant values from Haskell value. *Polymorphic proejction of SQL true value. +Polymorphic proejction of SQL false value. ;Polymorphic proejction of SQL set value from Haskell list. Unsafely get SQL term from . :Unsafely make projection unary operator from SQL keyword. FUnsafely make projection binary operator from string binary operator. NUnsafely make compare projection binary operator from string binary operator. MUnsafely make number projection binary operator from string binary operator. #Compare operator corresponding SQL = . #Compare operator corresponding SQL < . #Compare operator corresponding SQL <= . #Compare operator corresponding SQL > . #Compare operator corresponding SQL >= . #Compare operator corresponding SQL <> . #Logical operator corresponding SQL AND . #Logical operator corresponding SQL OR . #Logical operator corresponding SQL NOT . #Logical operator corresponding SQL EXISTS . 'Concatinate operator corresponding SQL || . 'Concatinate operator corresponding SQL || . Maybe type version. JUnsafely make number projection binary operator from SQL operator string. "Number operator corresponding SQL + . "Number operator corresponding SQL - . "Number operator corresponding SQL / . "Number operator corresponding SQL * . -Number negate uni-operator corresponding SQL -. "Number fromIntegral uni-operator. ;Unsafely show number into string-like type in projections. "Number operator corresponding SQL + . "Number operator corresponding SQL - . "Number operator corresponding SQL / . "Number operator corresponding SQL * . -Number negate uni-operator corresponding SQL -. "Number fromIntegral uni-operator. ;Unsafely show number into string-like type in projections. .Search case operator correnponding SQL search CASE.  Like, 1CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END Same as , but you can write like  whenlist   elseclause. Null default version of . .Simple case operator correnponding SQL simple CASE.  Like, 1CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END Uncurry version of , and you can write like ...   elseclause. Null default version of . "Binary operator corresponding SQL IN . Operator corresponding SQL IS NULL& , and extended against record types. Operator corresponding SQL NOT (... IS NULL)% , and extended against record type. /Operator from maybe type using record extended isNull. ;Deprecated. Operator from maybe type using record extended isNull. RANK() term.  DENSE_RANK() term.  DENSE_RANK() term.  ROW_NUMBER() term.  ROW_NUMBER() term. PERCENT_RANK() term. PERCENT_RANK() term.  CUME_DIST() term.  CUME_DIST() term. /Unsafely add placeholder parameter to queries. #Unsafely get placeholder parameter No placeholder semantics *Unsafely cast placeholder parameter type. <Provide scoped placeholder and return its parameter object. MProvide scoped placeholder and return its parameter object. Monadic version. Zipping projections. Binary operator the same as . Same as . other than using infered record constructor. Compose projection path I7 which has record result type using applicative style.  Compose seed of projection path I which has record result type. Compose record type  using applicative style. Compose seed of record type . Compose record type  using applicative style. Compose seed of record type . MZipping except for identity element laws against placeholder parameter type. Control phantom  type in SQL expression type . Control phantom  type in projection type . Control phantom ! type in placeholder parameters. Unsafely get SQL term from  Proejction. Unsafely get SQL term from . Unsafely make  from SQL terms. Unsafely make  from SQL terms. Unsafely make  from SQL terms. Unsafely make  from SQL terms. pSource projection object Result SQL expression string. SQL expression strings Result projection object  Error tag Each when clauses Else result projection Result projection Each when clauses Else result projection Result projection Each when clauses Else result projection Result projection Each when clauses Result projection Projection value to match Each when clauses Else result projection Result projection 5Projection value to match and each when clauses list Else result projection Result projection Projection value to match Each when clauses Result projection QQgunknown experimentalex8k.hibino@gmail.comNone4Interface to run recursively identity element laws. Interface to compose phantom  nested type. Projection interface. 9Unsafely make aggregation uni-operator from SQL keyword. Aggregation function COUNT. Aggregation function SUM.  Aggregation function SUM.  Aggregation function AVG.  Aggregation function AVG.  Aggregation function MAX.  Aggregation function MAX. Aggregation function MIN. Aggregation function MIN. Aggregation function EVERY. Aggregation function ANY. Aggregation function SOME. 3Get narrower projection along with projection path , and project into result projection type. 3Get narrower projection along with projection path , and project into result projection type.   phantom functor is c-ed. 3Get narrower projection along with projection path , and project into result projection type.  Source record * phantom functor and projection path leaf  functor are join-ed. =Get narrower projected expression along with projectino path  and strip  phantom type off. =Get narrower projected expression along with projectino path  and strip  phantom type off.  Projection path leaf is  case. ZGet narrower projection with flatten leaf phantom Maybe types along with projection path. YGet narrower projection with flatten leaf phantom Maybe types along with projection path , and project into result projection type.  Specialize  for  type. ?Base case definition to run recursively identity element laws.  Run right identity element law. Run left identity element law. Not  type is not processed. Compose " type in projection phantom type.  Project from  into  .  Project from  into . )     Source projection Projection path Narrower projected object Source .  type Projection path Narrower projected object.  type result Source .  phantom type Projection path.  type leaf Narrower projected object.  phantom type result Source projection type p.  phantom type Projection path Narrower projected expression.  phantom type is stripped off Source projection type p.  phantom type Projection path.  type leaf Narrower projected expression.  phantom type is stripped off Source .  phantom type Projection path  Narrower  . Flatten  phantom type Source .  phantom type Projection path  Narrower  . Flatten  phantom type Source .  phantom type Projection path 'Narrower flatten and projected object.           &     unknown experimentalex8k.hibino@gmail.comNone)Window specification building interface. ,Aggregated query building interface extends #. Add group by2 term into context and get aggregated projection. TLift interface from base qualify monad. Another constraint to support unique query.  Lift from qualify monad q into # m. & Qualify monad qualifies table form y. !(Lift interface from base qualify monad. "Lift from qualify monad q into # m. & Qualify monad qualifies table form y. #Query building interface. $Specify duplication. %Add restriction to last join. 'Restrict context interface (!Add restriction to this context. )(Specify ALL attribute to query context. *-Specify DISTINCT attribute to query context. +Add restriction to last join. ,7Add restriction to last join. Projection type version. -2Add restriction to this query. Expr type version. ..Add restriction to this not aggregated query. /Add GROUP BY2 term into context and get aggregated projection. 0=Add restriction to this aggregated query. Expr type version. 1NAdd restriction to this aggregated query. Aggregated Projection type version. 1Partitioning key to add into partition by clause Result context -Grouping element to add into group by clause Result context  !"#$% which represent restriction Restricted query context + | Unsafely join subquery with this query. &Attribute maybe or just y to join Result joined context and y result projection. '( which represent restriction Restricted query context )*+,-./ Projection to add into group by )Result context and aggregated projection 01 !"#$%&'()*+,-./01!" '(#$%&)*+,-./01 !"#$%&'()*+,-./01unknown experimentalex8k.hibino@gmail.comNone2'Type to accumulate query restrictions.  Type c- is context tag of restriction building like ( Flat (where) or Aggregated (having). 3Lift to 2 Add whole query restriction. 4Run 2 to get &  Resticted  instance.  Restricted # instance. ' instance. 234234234234unknown experimentalex8k.hibino@gmail.comNone50Context monad type to build partition keys set. 6/Context monad type to build grouping set list. 70Context monad type to build grouping power set. 81Context monad type to build single grouping set. 9Typeful aggregate element. :*Context type building partition keys set. ;'Context type building power group set. <*Context type building grouping sets list. =(Context type building one grouping set. >(Type to accumulate aggregating context.  Type ac@ is aggregating-context type like aggregating key set building, E aggregating key sets set building and partition key set building.  Type at is aggregating term type. ?Lift to >. @Run > to get terms list. AAdd GROUP BY5 element into context and get aggregated projection. B4Specify key of single grouping set from Projection. C$Specify key of single grouping set. D*Finalize and specify single grouping set. E*Specify key of rollup and cube power set. F1Finalize grouping power set as rollup power set. G/Finalize grouping power set as cube power set. HFinalize grouping set list. Partition clause instance Aggregated query instance.  Aggregated #.  Aggregated '. 56789:;<=>?@ABCDEFGH56789:;<=>?@ABCDEFGH>?=<;:@9A8765BCDEFGH56789:;<=>?@ABCDEFGHunknown experimentalex8k.hibino@gmail.comNone )Ordering term projection type interface. I%Type to accumulate ordering context.  Type c+ is ordering term projection context type. JLift to I. Add ordering terms. KAdd ordering terms. LAdd ascendant ordering term. MAdd descendant ordering term. NRun I to get   is ordering term.  with ordering.  with ordering. # with ordering. ' with ordering. IJOrder direction Ordering terms to add Result context with ordering KOrdering terms to add Order direction Result context with ordering LOrdering terms to add Result context with ordering MOrdering terms to add Result context with ordering NIJKLMNIJKLMN IJKLMNunknown experimentalex8k.hibino@gmail.comNoneO* type to accumulate join product context. PLift to O &Unsafely update join product context. #Add last join product restriction. (Unsafely join subquery with this query. QRun O to get q Joinable query instance. OPAttribute maybe or just y to join Result joined context and y result projection. QOPQOPQOPQunknown experimentalex8k.hibino@gmail.comNoneR.OrderedQuery monad type with placeholder type p!. Projection must be the same as I context type parameter c. SQCore query monad type used from flat(not-aggregated) query and aggregated query. T'Thin monad type for untyped structure. URun T. monad with initial state to get only result. V Get qualifyed table form query. WRead configuration. XExtract S computation. RSTUVWXRSTUVWXTUVWSXRRSTUVWXunknown experimentalex8k.hibino@gmail.comNoneY"RestrictedStatement type synonym.  Projection record type r must be  the same as 2 type parameter r. ZJRestrict only monad type used from update statement and delete statement. [Run Z to get &. 1Instance to lift from qualified table forms into Z. YZ[YZ[ZY[YZ[unknown experimentalex8k.hibino@gmail.comNone\$Simple (not-aggregated) query type.  SimpleQuery' p r == ] ( p,  r). ]*Simple (not-aggregated) query monad type. ^%Lift from qualified table forms into ]. _Run \ to get SQL string with Qualify computation. `Run \ to get y with Qualify computation. 1Instance to lift from qualified table forms into ]. \]^_\ to run Result SQL string with Qualify computation ` SimpleQuery' to run Result y with Qualify computation \]^_`]\^_`\]^_`unknown experimentalex8k.hibino@gmail.comNone a.Partition monad type for partition-by clause. bAggregated query type. b p r == c ( p,   r). cAggregated query monad type. %Lift from qualified table forms into c. dRun b to get SQL with T computation. eRun b to get y with T computation. fAdd  PARTITION BY term into context. g-Operator to make window function projection. 1Instance to lift from qualified table forms into c.  Restricted ' instance. abcdb to run Result SQL string with T computation eb to run Result y with T computation fgabcdefgcbdeafg abcdefgunknown experimentalex8k.hibino@gmail.comNonehUnique query monad type.  %Lift from qualified table forms into h. iRun  SimpleQuery to get y with Qualify computation.  1Instance to lift from qualified table forms into h. h   ih to run Result y with Qualify computation  hihih   i unknown experimentalex8k.hibino@gmail.comNonejTarget of assignment. k&Type to accumulate assigning context.  Type r is table record type. lLift to k mAdd an assignment. nAdd and assginment. oRun k to get   ' with ordering. jklmno jklmnoklmnjojklmno unknown experimentalex8k.hibino@gmail.comNonepAssignStatement type synonym. B Specifying assignments and restrictions like update statement. " Projection record type must be  the same as Target type parameter r. qITarget update monad type used from update statement and merge statement. rRun q. 1Instance to lift from qualified table forms into Z. pqrpqrqprpqrunknown experimentalex8k.hibino@gmail.comNone7s0Unique relation type to compose scalar queries. t:Restriction function type for direct style join operator. u*Relation type with place-holder parameter p and query result type r. vSimple u from c. wInfered u. xInterface to derive c type object. 'Sub-query Qualify monad from relation. #Basic monadic join operation using #. y*Join subquery with place-holder parameter p. query result is not . z#Join subquery. Query result is not . {*Join subquery with place-holder parameter p. Query result is . |Join subquery. Query result is . }List subQuery, for IN and EXIST with place-holder parameter p. ~List subQuery, for IN and EXIST.  Finalize ] monad and generate u with place-holder parameter p.  Finalize ] monad and generate u.  Finalize c monad and geneate u with place-holder parameter p.  Finalize c monad and geneate u. :Simplify placeholder type applying left identity element. ;Simplify placeholder type applying right identity element. :Basic direct join operation with place-holder parameters. 0Direct inner join with place-holder parameters. 5Direct left outer join with place-holder parameters. 6Direct right outer join with place-holder parameters. 5Direct full outer join with place-holder parameters. Basic direct join operation. Direct inner join. Direct left outer join. Direct right outer join. Direct full outer join. )Apply restriction for direct join style. Union of two relations. &Union of two relations. Not distinct. Subtraction of two relations. ,Subtraction of two relations. Not distinct. Intersection of two relations. -Intersection of two relations. Not distinct. 5Union of two relations with place-holder parameters. CUnion of two relations with place-holder parameters. Not distinct. ;Subtraction of two relations with place-holder parameters. ISubtraction of two relations with place-holder parameters. Not distinct. <Intersection of two relations with place-holder parameters. JIntersection of two relations with place-holder parameters. Not distinct. Generate SQL string from u with configuration. SQL string from u. Dump internal structure tree. "Unsafely specify unique relation. Discard unique attribute. #Basic monadic join operation using #. 1Join unique subquery with place-holder parameter p. 1Join unique subquery with place-holder parameter p. Query result is .  Finalize h monad and generate s.  Aggregated s. ,Scalar subQuery with place-holder parameter p. Scalar subQuery. Astuvwxyz{|}~Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation Left query to join Right query to join Join restrictions Result joined relation 2stuvwxyz{|}~2uvwxszy|{~}t?stuvwxyz{|}~unknown experimentalex8k.hibino@gmail.comNoneNot finalized Target monad type. .UpdateTarget type with place-holder parameter p and projection record type r. Not finalized Z monad type. -Restriction type with place-holder parameter p and projection record type r.  Finalize Z monad and generate .  Finalize Z monad and generate  with place-holder parameter p SQL WHERE clause  string from .  Finalize Target monad and generate .  Finalize Target monad and generate  with place-holder parameter p. Lift  to !. Update target columns are all. Lift  to 7. Update target columns are all. With placefolder type p.  Finalize Z monad and generate !. Update target columns are all.  Finalize Z monad and generate 7. Update target columns are all. With placefolder type p.  SQL SET clause and WHERE clause  string from   Show where clause. !"#$%& !"#$%& unknown experimentalex8k.hibino@gmail.comNone,4Untype interface for typed no-result type statments F with single type parameter which represents place-holder parameter p. (Delete type with place-holder parameter p. InsertQuery type. "Insert type to insert record type a. (Update type with place-holder parameter p. Update type with key type p and update record type a. @ Columns to update are record columns other than key columns, = So place-holder parameter type is the same as record type a. 'Query type with place-holder parameter p and query result type a. Unsafely make typed  from SQL string. From u into untyped SQL query string. From u into typed  with suffix SQL words. From u into typed . Unsafely make typed  from SQL string.  Make typed  from c and key columns selector I.  Make typed ( object using derived info specified by u type. Unsafely make typed  from SQL string. $Make untyped update SQL string from c and .  Make typed  from -, c and .  Make typed  using 5, c and .  Make typed  from -, derived table and   Make typed  from 5, derived table and   Make typed  from c and .  Update target is all column. Directly make typed  from c and Restrict monad context.  Update target is all column. Directly make typed  from c and Restrict monad context.  Update target is all column. Unsafely make typed , from single insert and chunked insert SQL. Unsafely make typed  from single insert SQL.  Make typed  from c and columns selector I with configuration parameter.  Make typed  from c and columns selector I. Infered . Unsafely make typed  from SQL string. +Make untyped insert select SQL string from c and u.  Make typed  from columns selector I and c and u. Infered . Unsafely make typed  from SQL string. $Make untyped delete SQL string from c and .  Make typed  from -, c and .  Make typed  from c and .  Make typed  from -, derived table and RestrictContext  Make typed  from 5, derived table and RestrictContext 'Show delete SQL string (Show insert SQL string. )Show insert SQL string. *Show update SQL string +Show update SQL string ,Show query SQL string AQuery SQL to type  Typed result -Restrict monad context ./01'()*+,661-./01'()*+, unknown experimentalex8k.hibino@gmail.comNone%Query restricted with specified key. ,Query restricted with specified unique key. -Query restricted with specified primary key. +Query restricted with infered primary key. Convert from Haskell type r into SQL value q# list expected by update form like \UPDATE <table> SET c0 = ?, c1 = ?, ..., cn = ? WHERE key0 = ? AND key1 = ? AND key2 = ? ...  using derived  RecordToSql proof object. Typed ! using specified constraint key. Typed  using infered primary key. s infered from table. -Unique key proof object which record type is a and key type is p. u to add restriction. Result restricted u -Unique key proof object which record type is a and key type is p. u to add restriction. Result restricted u .Primary key proof object which record type is a and key type is p. u to add restriction. Result restricted u u to add restriction. Result restricted u c to update Key with constraint c, record type r and columns type p  Result typed Update c to update  Result typed Update -Unique key proof object which record type is a and key type is p. Unique key value to specify. Result restricted u &unknown experimentalex8k.hibino@gmail.comNoneE  !*+,-./05IKLNOPUVWXYZ]^_`abcy     !#'()*+,-./01ABCDEFGHKLMRSTUVWXZ\]abcfghmnqstuvwxyz{|}~!unknown experimentalex8k.hibino@gmail.comNone2'Rule template to infer constraint key. $Rule template to infer primary key. $Rule template to infer primary key. %Rule template to infer not-null key. %Rule template to infer not-null key. 3Column projection path I template. 4Column projection path I and constraint key template. Column projection path I templates. TMake column projection path and constraint key templates using default naming rule. 5*Rule template to infer table derivations. 64Template to define infered entries from table type. c and u templates. Make TableDerivationI variable expression template from table name using default naming rule. Make cI variable expression template from table name using default naming rule. Make uI variable expression template from table name using default naming rule. Make template for  instance. 7Make template for record % instance using default naming rule. KMake templates about table and column metadatas using default naming rule. QMake templates about table, column and haskell record using default naming rule. Template of derived primary . Template of derived primary Update. (SQL templates derived from primary key. BSQL templates derived from primary key using default naming rule. 8!All templates about primary key. 9"All templates about not-null key. =Generate all templtes about table using default naming rule. Unsafely inlining SQL string  in compile type. 9Extract param type and result type from defined Relation Inlining composed  in compile type. DGenerate all templates against defined record like type constructor + other than depending on sql-value type. "2Constraint type  Record type  Key type Indexes specifies key Result X declaration  Record type  Key type Indexes specifies key #Result constraint key declarations  Table name  Column type Primary key index 'Declarations of primary constraint key  Record type  Column index Result ColumnConstraint declaration  Table name NotNull key index 'Declaration of not-null constraint key 3 Record type !Column declaration variable name 1Column index expression in record (begin with 0)  Column type #Column projection path declaration 4/May Constraint type and constraint object name  Record type !Column declaration variable name 1Column index expression in record (begin with 0)  Column type #Column projection path declaration Record type name Column info list $Column projection path declarations Record type name Column info list $Column projection path declarations 56 Table declaration variable name #Relation declaration variable name +Insert statement declaration variable name 0InsertQuery statement declaration variable name  Record type Table and Relation declaration  Table declaration variable name #Relation declaration variable name +Insert statement declaration variable name 0InsertQuery statement declaration variable name  Record type (Table name in SQL ex. FOO_SCHEMA.table0  Column names Table and Relation declaration :;Table name string Result var Exp <Table name string Result var Exp =Table name string Result var Exp 7%Configuration to generate query with  Schema name  Table name +Column names and types and constraint type Result declarations %Configuration to generate query with  Schema name  Table name Column names and types Record derivings Result declarations $Variable name of result declaration Parameter type of  Record type of  u expression Result  declaration $Variable name of result declaration Parameter type of Update Record type of Update c expression Result Update declaration :Variable name of select query definition from primary key >Variable name of update statement definition from primary key Primary key type  Record type Relation expression Table expression Result declarations Table name of Database Primary key type  Record type Relation expression Table expression Result declarations 8Table name string Type of primary key Indexes specifies primary key Result declarations 9%Configuration to generate query with Schema name string of Database Table name string of Database Column names and types derivings for Record type Primary key index Not null key index Result declarations Query parameter type Query result type SQL string query to inline  Variable name for inlined query Result declarations &Variable name which has Relation type 8Extracted param type and result type from Relation type "Top-level variable name which has u type Object which has u type Configuration to generate SQL suffix SQL words )Variable name to define as inlined query Result declarations Type constructor name Resutl declaration "23456:;<=789>'()'(*'(+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w x y z { | } ~     u          u   u y = s t =      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{{w        !!!!!!!!!!!! ! ! ! ! !!!!!!""""""" !"#$%&'()*+(,-.(/0123452367238923:;<=>?<@>ABCDEBFDGHIJKILMINOPQRSTUVWXYZ[\KLUY]^_`abcdem#f#g#h#i#j#k#l#m#n#o#p#q#f#r#s#&#t#, u v w x'yz q { | } ~  u'(         v               6 7                 $$$$$$$n%%%%%r%%        NUZeckwww  l  )  !"#$!%!&!'!(!)!*!+!,!-!.!/!01relational-query-0.3.0.4$Database.Relational.Query.Constraint%Database.Relational.Query.Expr.Unsafe Database.Relational.Query.Scalar!Database.Relational.Query.ContextDatabase.Relational.Query.PureDatabase.Relational.Query.Expr#Database.Relational.Query.Component,Database.Relational.Query.Monad.Trans.Config#Database.Relational.Query.Pi.UnsafeDatabase.Relational.Query.PiDatabase.Relational.Query.TableDatabase.Relational.Query.Sub$Database.Relational.Query.ProjectionDatabase.Relational.Query.SQL%Database.Relational.Query.Projectable-Database.Relational.Query.ProjectableExtended%Database.Relational.Query.Monad.Class1Database.Relational.Query.Monad.Trans.Restricting1Database.Relational.Query.Monad.Trans.Aggregating.Database.Relational.Query.Monad.Trans.Ordering*Database.Relational.Query.Monad.Trans.Join$Database.Relational.Query.Monad.Type(Database.Relational.Query.Monad.Restrict&Database.Relational.Query.Monad.Simple)Database.Relational.Query.Monad.Aggregate&Database.Relational.Query.Monad.Unique/Database.Relational.Query.Monad.Trans.Assigning&Database.Relational.Query.Monad.Assign"Database.Relational.Query.Relation Database.Relational.Query.EffectDatabase.Relational.Query.Type!Database.Relational.Query.DerivesDatabase.Relational.Query.TH&Database.Relational.Query.Internal.SQL*Database.Relational.Query.Internal.Product/Database.Relational.Query.Monad.Trans.JoinState-Database.Relational.Query.Monad.Trans.QualifyDatabase.Relational.Querypersistable-record-0.1.0.0Database.Record.KeyConstraintUniqueNotNullPrimaryExprsqlExprshowExpr ScalarDegreedefineScalarDegreePowerSetListSet OverWindowExists AggregatedFlatShowConstantTermsSQLshowConstantTermsSQLProductConstructorproductConstructor valueExprjustfromJustexprAnd Assignments Assignment AssignTerm AssignColumn OrderingTerms OrderingTerm OrderColumnOrderDescAsc AggregateElem AggregateSetAggregateBitKeyAggregateColumnRefQueryRestriction DuplicationDistinctAllProductUnitSupportPUNotSupported PUSupportedConfigproductUnitSupportchunksInsertSizenormalizedTableName ColumnSQL columnSQL columnSQL'showsColumnSQL defaultConfigshowsDuplication composeWhere composeHavingaggregateColumnRefaggregatePowerKeyaggregateGroupingSetaggregateRollup aggregateCube aggregateSetsaggregateEmptycomposeGroupBycomposePartitionBycomposeOrderBy composeSets composeOver QueryConfigrunQueryConfig queryConfigaskQueryConfigPiunsafeExpandIndexespfmappapwidth<.>pidefinePidefineDirectPi'defineDirectPiid'fst'snd'HasConstraintKey constraintKeyKeyindexesunsafeDefineConstraintKeytableConstraint projectionKey uniqueKeyderivedUniqueKeyTableDerivable derivedTableTableUntypedname'width'columns'!unTypename shortNamecolumnsindextoMaybetable JoinProductQueryProductNode QueryProductUntypedProjectionProjectionUnit Qualified QualifierSubQuery fromTable flatSubQueryaggregatedSubQueryunionexcept intersectunitSQLshowSQLtoSQL qualifier unQualifyqualify queryWidthcolumnuntypedProjectionFromColumns#untypedProjectionFromScalarSubQuery#untypedProjectionFromJoinedSubQuerywidthOfUntypedProjectioncolumnsOfUntypedProjectionListProjection ProjectionuntypeunsafeFromColumnsunsafeFromQualifiedSubQueryunsafeFromScalarSubQueryunsafeFromTablepredicateProjectionFromExprpiMaybepiMaybe' flattenMaybeunsafeChangeContextunsafeToAggregated unsafeToFlat#unsafeShowSqlNotNullMaybeProjectionlist unsafeListProjectionFromSubQueryunsafeShowSqlListProjection QuerySuffixshowsQuerySuffixupdatePrefixSQL updateSQL'updateOtherThanKeySQL'updateOtherThanKeySQLinsertPrefixSQLinsertSizedChunkSQL insertSQLdeletePrefixSQL'deletePrefixSQLProjectableApplicative|*|ProjectableFunctor|$|ProjectableIdZipleftIdrightIdProjectableMaybe PlaceHoldersSqlBinOpProjectableShowSql unsafeShowSqlSqlProjectableunsafeProjectSqlTermsunsafeShowSqlProjectionexprunsafeProjectSqlunsafeValueNullvalue valueTrue valueFalsevaluesunsafeShowSqlExpr unsafeUniOp unsafeBinOp.=..<..<=..>..>=..<>.and'or'not'exists.||.?||?.+..-../..*.negate' fromIntegral'showNum?+??-??/??*? negateMaybefromIntegralMaybe showNumMaybe caseSearch casesOrElsecaseSearchMaybecase' casesOrElse' caseMaybein' isNothingisJust fromMaybe fromMaybe'rank denseRank dense_rank rowNumber row_number percentRank percent_rankcumeDist cume_distunsafeAddPlaceHoldersunsafePlaceHoldersunitPlaceHolder placeholder' placeholder projectZip><ipfmapProjectableRunIdsZiprunIdsProjectableFlattenMaybeflattenunsafeAggregateOpcountsumMaybesum'avgMaybeavgmaxMaybemax'minMaybemin'everyany'some'?!?!?.!.?flattenPiMaybe!?? flattenPhMonadPartitionunsafeAddPartitionKeyMonadAggregateunsafeAddAggregateElementMonadQualifyUniqueliftQualifyUnique MonadQualify liftQualify MonadQuerysetDuplication restrictJoinunsafeSubQuery MonadRestrictrestrictall'distinctonEonwheresEwheresgroupByhavingEhaving Restrictings restrictingsextractRestrictPartitioningSetAggregatingSetListAggregatingPowerSetAggregatingSet AggregateKeyPartitioningSetTAggregatingPowerSetTAggregatingSetListTAggregatingSetT Aggregatings aggregatingsextractAggregateTermsgroupBy'keykey'setbkeyrollupcube groupingSets Orderings orderingsorderByascdescextractOrderingTerms QueryJoinjoin'extractProduct OrderedQuery QueryCoreConfigureQueryconfigureQuery qualifyQuery askConfig extractCoreRestrictedStatementRestrictextract SimpleQuery QuerySimplesimple toSubQueryWindowAggregatedQueryQueryAggregate partitionByover QueryUnique AssignTarget Assignings assigningsassignTo<-#extractAssignmentsAssignStatementAssignUniqueRelationJoinRestrictionRelationderivedRelationtableOfquery'query queryMaybe' queryMaybe queryList' queryList relation'relationaggregateRelation'aggregateRelationrightPhleftPhinner'left'right'full'innerleftrightfullon'unionAll exceptAll intersectAllunion' unionAll'except' exceptAll' intersect' intersectAll'sqlFromRelationWithsqlFromRelationdump unsafeUniqueunUnique uniqueQuery'uniqueQueryMaybe'uniqueRelation'aggregatedUnique queryScalar' queryScalarUpdateTargetContext UpdateTargetRestrictionContext Restriction restriction restriction'sqlWhereFromRestriction updateTarget updateTarget'liftTargetAllColumnliftTargetAllColumn'updateTargetAllColumnupdateTargetAllColumn'sqlFromUpdateTargetUntypeableNoFetch untypeNoFetchDelete untypeDelete InsertQueryuntypeInsertQueryInsert untypeInsertuntypeChunkInsertchunkSizeOfInsertUpdate untypeUpdate KeyUpdate updateKeyuntypeKeyUpdateQuery untypeQueryunsafeTypedQueryrelationalQuerySQLrelationalQuery'relationalQueryunsafeTypedKeyUpdatetypedKeyUpdatetypedKeyUpdateTableunsafeTypedUpdate updateSQL typedUpdate' typedUpdatederivedUpdate' derivedUpdatetypedUpdateAllColumnrestrictedUpdateAllColumnrestrictedUpdateTableAllColumnunsafeTypedInsert'unsafeTypedInsert typedInsert' typedInsert derivedInsertunsafeTypedInsertQueryinsertQuerySQLtypedInsertQueryderivedInsertQueryunsafeTypedDelete deleteSQL typedDelete' typedDeletederivedDelete' derivedDelete specifiedKeyuniqueprimary'primaryupdateValuesWithKeyupdateByConstraintKey primaryUpdatederivedUniqueRelationdefineHasPrimaryKeyInstance"defineHasPrimaryKeyInstanceDefaultdefineHasNotNullKeyInstance"defineHasNotNullKeyInstanceDefault defineColumnsdefineColumnsDefaultdefineTableTypesderivationExpDefaulttableVarExpDefaultrelationVarExpDefault defineProductConstructorInstancedefineTableTypesDefault defineTableTypesAndRecordDefaultdefinePrimaryQuerydefinePrimaryUpdatedefineSqlsWithPrimaryKeydefineSqlsWithPrimaryKeyDefaultdefineTableDefaultunsafeInlineQuery reifyRelation inlineQuerymakeRelationalRecordDefault StringSQL stringSQLbaseGHC.BaseString showStringSQL rowStringSQLrowPlaceHolderStringSQLrowListStringSQLrowListStringString $fShowExpr$fScalarDegreeMaybe intExprSQLescapeStringToSqlExpr stringExprSQL$fShowConstantTermsSQL(,)$fShowConstantTermsSQLMaybe Data.MaybeMaybe$fShowConstantTermsSQLLocalTime time-1.4.0.1Data.Time.LocalTime.LocalTime LocalTime$fShowConstantTermsSQLTimeOfDayData.Time.LocalTime.TimeOfDay TimeOfDay$fShowConstantTermsSQLDayData.Time.Calendar.DaysDay$fShowConstantTermsSQLDoubleghc-prim GHC.TypesDouble$fShowConstantTermsSQLFloatFloat$fShowConstantTermsSQLBoolBool$fShowConstantTermsSQLCharChar$fShowConstantTermsSQLText text-0.11.3.1Data.Text.Lazy.InternalText$fShowConstantTermsSQLText0Data.Text.Internal $fShowConstantTermsSQLByteStringbytestring-0.10.0.2Data.ByteString.Lazy.Internal ByteString!$fShowConstantTermsSQLByteString0Data.ByteString.Internal$fShowConstantTermsSQL[]$fShowConstantTermsSQLInt64GHC.IntInt64$fShowConstantTermsSQLInt32Int32$fShowConstantTermsSQLInt16Int16$fProductConstructor(->) intTermsSQLstringTermsSQL floatTermsconstantTimeTermsshowMaybeTermsunsafeCastExpr ColumnSQL'stringFromColumnSQLcomposeRestrict GroupingSetsCubeRollup ColumnRefshowsAggregateColumnRefcommaedpCommashowsAggregateBitKey$fShowColumnSQL'$fFunctorColumnSQL'transformers-0.3.0.0Control.Monad.Trans.ReaderReaderTNode ProductTreeNodeAttrnodeAttrnodeTreenode growRight growProductproductrestrictProduct'restrictProduct$fFoldableProductTreeJoinLeafJust'Pi'unsafeCastRecordWidthmap definePi'Database.Record.PersistablePersistableRecordWidthMapLeftestunsafePiAppend'unsafePiAppend unsafeCastsnd'' KeyConstraintunsafeReturnKey mapConstraint columnArrayfromTableToSQLfromTableToNormalizedSQL normalizedSQLtoSQLs showQualifier columnFromIdqualifiedSQLas qualifiedFormwidthOfProjectionUnitcolumnOfProjectionUnitcolumnOfUntypedProjectionshowsQueryProductshowsJoinProduct$fFunctorQualifiedFunctorScalar NormalizedColumnsBinBinOpSetOp IntersectExceptUnion showsSetOp' showsSetOpsetBinselectPrefixSQL showUnitSQLcolumnN asColumnNprojectionUnitFromColumns projectionUnitFromScalarSubQueryunitUntypedProjection JoinContextprimeJoinContextupdateProduct' updateProduct joinProductQualifyevalQualifyPrimenewAliasAliasId unsafeProjectSubListuntypeProjectiontypedProjectionnotNullMaybeConstraintinsertChunkSQLfmapexprOfProjectionunsafeSqlTermsProjection compareBinOp monoBinOp monoBinOp'unsafeCastPlaceHolders$fProjectableApplicativePi$fProjectableFunctorPi"$fProjectableApplicativeProjection$fProjectableFunctorProjection$$fProjectableApplicativePlaceHolders $fProjectableFunctorPlaceHolders$fProjectableIdZipPlaceHolders$fProjectableMaybeExpr$fProjectableMaybeProjection$fProjectableMaybePlaceHolders$fProjectableShowSqlProjection$fProjectableShowSqlExpr$fSqlProjectableExpr$fSqlProjectableProjection$fSqlProjectableProjection0$fSqlProjectableProjection1unsafeFlatUniOp parenBinStrunsafeCastProjectable unsafeSqlWord whensClauseunsafeUniTermFunctionunsafeProjectPlaceHolder'unsafeProjectPlaceHolder Projectable$fProjectableRunIdsZipaa$fProjectableRunIdsZip(,)b$fProjectableRunIdsZip(,)b0#$fProjectableFlattenMaybeMaybeMaybe$fProjectableFlattenMaybeMaybeb$fProjectableProjectionExpr!$fProjectableProjectionProjectionAggregatedContextproject projectPiprojectPiMaybeprojectPiMaybe'projectFlattenPiMaybe$fAggregatedContextOverWindow$fAggregatedContextAggregatedupdateRestriction$fMonadAggregateRestrictings$fMonadQueryRestrictings$fMonadRestrictcRestrictings$fMonadPartitionAggregatings$fMonadAggregateAggregatings$fMonadQueryAggregatings$fMonadRestrictcAggregatingsunsafeAggregateWithTermextractTermList finalizePowerProjectableOrderingupdateOrderBys$fProjectableOrderingProjection$fMonadPartitionOrderings$fMonadAggregateOrderings$fMonadQueryOrderings$fMonadRestrictrcOrderings orderTermsControl.Monad.Trans.State.LazyStateT updateContextupdateJoinRestrictionunsafeSubQueryWithAttr$fMonadQueryQueryJoin!$fMonadQualifyQualifyRestrictings$fMonadQualifyQualifyOrderingsaggregatedQuery$fMonadRestrictFlatRestrictings extractWindow queryUnique&$fMonadQualifyUniqueQualifyQueryUnique$fMonadRestrictcAssigningstargetProjection$fMonadQualifyQualifyAssigningssubQueryQualifyFromRelation queryWithAttrjoinuniqueQueryWithAttrplaceHoldersFromRelation queryList0 addUnitPHunsafeCastPlaceHolderunsafeLiftAppend liftAppend liftAppend'$fShowRelation$fShowRestrictionrunRestriction_runUpdateTargetupdateAllColumn$fShowUpdateTarget $fShowDelete$fShowInsertQuery $fShowInsert $fShowUpdate$fShowKeyUpdate $fShowQuery targetTablerestrictedTable$fUntypeableNoFetchDelete$fUntypeableNoFetchUpdate$fUntypeableNoFetchInsertdefineHasConstraintKeyInstancecolumnTemplate'columnTemplatedefineTableDerivableInstancedefineTableDerivations'defineProductConstructorInstanceDefaultdefineWithPrimaryKeyDefaultdefineWithNotNullKeyDefaulttableSQLderivationVarNameDefaulttableVarNameDefaultrelationVarNameDefault