Y+~Y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"(#2014 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeY!String wrap type for SQL strings.ZY from [.\Y to [.]Row String of SQL values.^Place holder row String of SQL._List String of SQL.`List String of SQL.YZ\]^_`YZ\]^_`YZ\]^_`2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone35*Constraint which represents scalar degree. instance templates.aa2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe#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    2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone35 %Interface for constant SQL term list.CSpecify tuple like record constructors which are allowed to define ProjectableFunctor.The constructor which has type r.b!Constant integral SQL expression.cEscape [$ for constant SQL string expression.dFrom [% into constant SQL string expression.String interface of  .e$Constant SQL terms of '(a, b)' type.fConstant SQL terms of g# type. Width inference is required.hConstant SQL terms of iT. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal with UTC timezone.jConstant SQL terms of kB. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal.lConstant SQL terms of m.nConstant SQL terms of o.pConstant SQL terms of q.rConstant SQL terms of s(. Caution for floating-point error rate.tConstant SQL terms of u(. Caution for floating-point error rate.vConstant SQL terms of w.xConstant SQL terms of y.zConstant SQL terms of {.|Constant SQL terms of }.~Constant SQL terms of .Constant SQL terms of .Constant SQL terms of [.Constant SQL terms of U. Use this carefully, because this is architecture dependent size of integer type.Constant SQL terms of .Constant SQL terms of .Constant SQL terms of .Constant SQL terms of .$ProductConstructor instance of pair.# bcdefhjlnprtvxz|~  !  bcdefhjlnprtvxz|~2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone4;NProjection path from type r0 into type r16. This type also indicate key object which type is r1 for record type r0.'Projection path primary structure type.&Unsafely untype key to expand indexes.MUnsafely cast width proof object of record. Result record must be same width.Projectable fmap of  type.Projectable ap of  type.Get record width proof object.Get record width.Compose projection path.Compose projection path. g phantom functor is -ed.Compose projection path. g phantom functors are join -ed like >=>.$Unsafely project untyped value list.*Unsafely define projection path from type r0 into type r1.*Unsafely define projection path from type r0 into type r1. Use inferred .*Unsafely define projection path from type r0 into type r1.*Unsafely define projection path from type r0 into type r1. Use inferred .Index of flat SQL value listResult projection pathIndex of flat SQL value listResult projection pathIndexes of flat SQL value listResult projection pathIndexes of flat SQL value listResult projection path  2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneIdentity projection path.!Projection path for fst of tuple.!Projection path for snd of tuple.Projection path of fst.Projection path of snd.  2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone3457  Constraint " inference interface.!Infer constraint key."-Constraint Key proof object. Constraint type c, record type r and columns type ct.#,Index of key which specifies constraint key. Width of key.$Unsafely generate constraint "( proof object using specified key index.%Get table constraint  proof object from constraint ".&1Get projection path proof object from constraint ".6Unsafe. Make constraint key to add column phantom type*Map from table constraint into constraint ".'Derive  constraint " from  constraint "(Infered  constraint ". Record type r has unique key which type is ct derived from primay key. !"#$-Key indexes which specify this constraint key"Result constraint key proof object%&'(  !"#$%&'( "#$%&' !( !"#$%&'(2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone35-)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 column0)Order direction. Ascendant or Descendant.3Typeful aggregate element.4Type for group-by tree5Type for grouping set6Type for group key.7Type for group-by term8#Result record duplication attribute;2Configuration for quotation of identifiers of SQL.>$Unit of product is supported or not.AConfiguration type.I'Schema name qualify mode in SQL string.J)Schema qualified table name in SQL stringK&Not qualified table name in SQL stringLL/ type to customize names of expanded templates.PColumn SQL string typeSimple wrap typeQP from stringRP from YString from ColumnSQLSStringSQL from ColumnSQLTDefault configuration.U%Compose duplication attribute string.V Single term aggregation element.WKey of aggregation power set.XSingle grouping set.YRollup aggregation element.ZCube aggregation element.[Grouping sets aggregation.\Empty aggregation.]0Compose GROUP BY clause from AggregateElem list.^9Compose PARTITION BY clause from AggregateColumnRef list._Extract typed projection from 3.`Extract untyped term from 3.a5Unsafely bind typed-projection and untyped-term into 3.b*Compose ORDER BY clause from OrderingTermscCompose SET clause from ).dCompose VALUES clause from ).eCompose OVER (PARTITION BY ... ) clause.O)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde=)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde=PQRSLMNOIJKABCDEFGHT>?@89:;<=U7654V\WXYZ[]^3_`a012/.-b,+*)cde2)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonefInference rule of h existence.hPhantom typed table typeiUntyped typed table typejName string of table in SQLkWidth of tableColumn name strings in SQLlColumn name strings in SQLm,Column name string in SQL specified by indexn Untype table.oName string of table in SQLp)Not qualified name string of table in SQLqWidth of tablerColumn name strings in SQLs,Column name string in SQL specified by indextCast phantom type into g type.u+Unsafely generate phantom typed table type.fghijklm Column indexColumn name String in SQLnopqrs Column indexColumn name String in SQLtufghijklmnopqrstuijklmhnopqrsutfgfghijklmnopqrstu$2015-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone-vType for restriction of query.w=Phantom typed projection. Projected into Haskell record type t.Discard projection value type xType for join product of query.y*Product noe with join restriction builder.+Product tree with join restriction builder.#Product tree with join restriction..Product node. node attribute and product tree.KProduct tree type. Product tree is constructed by left node and right node.znode attribute for product.{'Untyped projection. Forgot record type.|Projection structure unit}Qualified query.~Qualifier type.Sub-query typeSet binary operators Set operatorsUnsafely type projection value. instance of }(vwxyz{|}~$vwxyz{|}~vwxyz{|}~ 2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone* from h.Unsafely generate flat  from untyped components.Unsafely generate aggregated  from untyped components.Union binary operator on Except binary operator on Intersect binary operator on  Width of .SQL to query table.*Generate normalized column SQL from table.Normalized column SQL-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 qualifierAlias string from qualifierBinary operator to qualify.9Qualified expression from qualifier and projection index.From } SQL string into [. Width of } SubQUery.Get column SQL string of .1Get 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 {.Get column SQL string of {.)Get column SQL string list of projection.)Get column SQL string list of projection.Unsafely get SQL term from  Proejction.Unsafely generate w from SQL string list.Get node attribute.Get tree from node.6Show product tree of query into SQL. StringSQL result.Shows join product of query.Compose SQL String from v.Compose WHERE clause from v.Compose HAVING clause from v.4Typed h metadataResult sub-query SQL and top-level SQLSource w Column indexResult SQL stringSource wResult SQL string listSource wResult SQL string list!SQL string list specifies columnsResult w%vwxyz{|}~%~}w|{xzyv4%2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneC&Monad type to qualify SQL table forms.8Run qualify monad with initial state to get only result.*Generated new qualifier on internal state.Lift to Get qualifyed table form query.Query to qualifyResult with updated state&2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneJoinContext type for QueryJoin.Initial .Update product of .6Finalize context to extract accumulated query product.'2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone&Push new tree into product right term.+Push new leaf node into product right term.1Add restriction into top product of product tree.6Add restriction into top product of product tree node. Current treeNew tree to push into right Result node Current treeNew leaf to push into right Result nodeProduct to restrictRestriction to addResult product)Target node which has product to restrictRestriction to add Result node 2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneC. type to require query generate configuration.Run  to expand with configurationLift to .Read configuration. 2015 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone *Relation type with place-holder parameter p and query result type r.&Thin monad type for untyped structure.Run - monad with initial state to get only result.Get qualifyed table form query.Read configuration.AUnsafely type qualified subquery into record typed relation type.&Sub-query Qualify monad from relation.9Simplify placeholder type applying left identity element.:Simplify placeholder type applying right identity element.Generate SQL string from  with configuration.SQL string from .Dump internal structure tree.  2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone4Projection type for row list.Unsafely get SQL term from  Proejction.)Get column SQL string list of projection. Width of w. Unsafely get untyped projection.Unsafely generate w# from qualified (joined) sub-query.Unsafely generate w from scalar sub-query.Unsafely generate unqualified w from h.Unsafely generate w from SQL expression strings.Unsafely trace projection path.&Trace projection path to get narrower w.&Trace projection path to get narrower w. From g type to g type.&Trace projection path to get narrower w. From g type to g* type. Leaf type of projection path is g.Composite nested g on projection phantom type. Cast into g 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 w type.Projectable ap of w type.Make row list projection from w list.Make row list projection from .IMap projection show operatoions and concatinate to single SQL expression.  Source wResult SQL string listSource wProjection path Narrower wSource w. g typeProjection path Narrower w. g type resultSource w. g typeProjection path. g type leaf Narrower w. g type result  ww    2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone Type for query suffix wordsExpand query suffix words%Generate prefix string of update SQL.`Generate update SQL by specified key and table. Columns name list of table are also required.`Generate update SQL by specified key and table. 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.0Generate size measured records chunk insert SQL.Generate insert SQL.IGenerate all column delete SQL by specified table. Untyped table version.2Generate all column delete SQL by specified table.  Table nameColumn name list to updateKey column name list Result SQL Table nameColumn name listKey column indexes Result SQLTable metadata Key columns Result SQL Records count to insertColumns selector to insertTable metadata Result SQLColumns selector to insertTable metadata#Chunk size threshold (column count)%Result SQL and records count of chunkColumns selector to insertTable metadata Result SQLTable metadata Result SQL  2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone345_*Weaken applicative functor on projections. Method like .Weaken functor on projections. Method like .)Zipping except for identity element laws.Interface to control g of phantom type in projections."Cast projection phantom type into g.Compose nested g 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 term from projection object.(Interface to project SQL terms unsafely.+Unsafely project from SQL expression terms.7Unsafely project from SQL strings. String interface of .!Unsafely Project single SQL term.8Unsafely Project single SQL string. String interface of .)Polymorphic projection of SQL null value.JGenerate 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.WUnsafely generate SQL expression string from projection object. String interface of .9Unsafely make projection unary operator from SQL keyword.EUnsafely make projection binary operator from string binary operator.MUnsafely make compare projection binary operator from string binary operator.NUnsafely make numrical 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.*String-compare operator corresponding SQL LIKE .*String-compare operator corresponding SQL LIKE .*String-compare operator corresponding SQL LIKE .*String-compare operator corresponding SQL LIKE . Maybe type version.IUnsafely 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 ENDSame 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.RANK() term. DENSE_RANK() term. ROW_NUMBER() term.PERCENT_RANK() term. CUME_DIST() term..Unsafely add placeholder parameter to queries."Unsafely get placeholder parameterNo placeholder semantics)Unsafely cast placeholder parameter type.;Provide scoped placeholder and return its parameter object.LProvide scoped placeholder and return its parameter object. Monadic version.Zipping projections.Binary operator the same as .Same as . other than using inferred record constructor.Compose projection path 6 which has record result type using applicative style. Compose seed of projection path  which has record result type.Compose record type w using applicative style.Compose seed of record type w.Compose record type  using applicative style.Compose seed of record type .LZipping except for identity element laws against placeholder parameter type.Control phantom g type in projection type w.Control phantom g type in placeholder parameters.Unsafely get SQL term from  Proejction.Unsafely make w from SQL terms.Unsafely make w from SQL terms. Unsafely make w from SQL terms.l!Source projection objectResult SQL expression string."SQL expression stringsResult projection objectSQL expression stringsResult projection objectSource projection objectResult SQL expression string.#$%& Error tagEach when clausesElse result projectionResult projectionEach when clausesElse result projectionResult projectionEach when clausesElse result projectionResult projectionEach when clausesResult projection Projection value to matchEach when clausesElse result projectionResult projection 4Projection value to match and each when clauses listElse result projectionResult projection Projection value to matchEach when clausesResult projection  '()*+ P     P     c!"#$%&     '()*+  2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone34573Interface to run recursively identity element laws.Interface to compose phantom g nested type.!8Unsafely 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./6Get narrower projection along with projection path g phantom functor is -ed.0pGet narrower projection along with projection path and project into result projection type. Source record g* phantom functor and projection path leaf g functor are join-ed.1YGet narrower projection with flatten leaf phantom Maybe types along with projection path.2YGet narrower projection with flatten leaf phantom Maybe types along with projection path.3 Specialize  for  type.,>Base case definition to run recursively identity element laws.-Run right identity element law..Run left identity element law./Not g type is not processed.0Compose g! type in projection phantom type. 1!"#$%&'()*+,-.Source projectionProjection pathNarrower projected object/Source w. g typeProjection pathNarrower projected object. g type result0Source w. g phantom typeProjection path. g type leafNarrower projected object. g phantom type result1Source w. g phantom typeProjection path Narrower w . Flatten g phantom type2Source w. g phantom typeProjection path&Narrower flatten and projected object.3,-./023 !"#$%&'()*+,-./0123 1./02!"$#&%('*)+,-3 1!"#$%&'()*+,-./0123,-./023./022013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone34574(Window specification building interface.5Add  PARTITION BY term into context.6,Aggregated query building interface extends ;.7Add GROUP BY1 term into context and get aggregated projection.9'Lift interface from base qualify monad.:Lift from qualify monad q into ;* m. Qualify monad qualifies table form SubQuery.;Query building interface.<Specify duplication.=Add restriction to last join.>+Join sub-query with place-holder parameter p. query result is not g.?+Join sub-query with place-holder parameter p. Query result is g.@Restrict context interfaceA Add restriction to this context.B'Specify ALL attribute to query context.C,Specify DISTINCT attribute to query context.D6Add restriction to last join. Projection type version.E-Add restriction to this not aggregated query.FMAdd restriction to this aggregated query. Aggregated Projection type version.4567Projection to add into group by0Result context and aggregated projection | Add GROUP BYS term into context and get aggregated projection. Non-traditional group-by version.87Key to aggretate for non-traditional group-by interface(Result context and aggregated projection9:;<=w which represent restrictionRestricted query context>?@Aw which represent restrictionRestricted query contextBCDEF4456789:;<=>?@ABCDEF9:@A;<=>?67845BCDEF 456789:;<=>?@ABCDEF42013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357CG/Context monad type to build partition keys set.H.Context monad type to build grouping set list.I/Context monad type to build grouping power set.J0Context monad type to build single grouping set.K)Context type building partition keys set.L&Context type building power group set.M)Context type building grouping sets list.N'Context type building one grouping set.O0Type to accumulate aggregating context. Type ac is aggregating-context type like aggregating key set building, aggregating key sets set building and partition key set building. Type at is aggregating term type.PLift to O.QRun O to get terms list.R3Specify key of single grouping set from Projection.S#Specify key of single grouping set.T)Finalize and specify single grouping set.U)Specify key of rollup and cube power set.V0Finalize grouping power set as rollup power set.W.Finalize grouping power set as cube power set.XFinalize grouping set list.5Partition clause instance6Aggregated query instance.7 Aggregated ;.8 Aggregated 9.9 Aggregated @.GHIJKLMNO:P;<Q=RSTU>VWX56789GHIJKLMNOPQRSTUVWXOPNMLKQJIHGRSTUVWXGHIJKLMNO:P;<Q=RSTU>VWX567892013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone3457C?(Ordering term projection type interface.Y-Type to accumulate ordering context. Type c* is ordering term projection context type.ZLift to Y.@Add ordering terms.[Add ordering terms.\Add ascendant ordering term.]Add descendant ordering term.^Run Y to get -Aw is ordering term.B4 with ordering.C6 with ordering.D; with ordering.E9 with ordering.F@ with ordering.?GYHZ@Order directionOrdering terms to addResult context with ordering[Ordering terms to addOrder directionResult context with ordering\Ordering terms to addResult context with ordering]Ordering terms to addResult context with ordering^ABCDEF-YZ[\]^YZ-[\]^?GYHZ@[\]^ABCDEF2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357C_Target of assignment.`.Type to accumulate assigning context. Type r is table record type.aLift to `bAdd an assignment.cAdd and assginment.dRun ` to get )I9 with assigning.J@ with assigning. _`KaLbcdIJ_`abcd`abc_d _`KaLbcdIJc2015 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonee6Target register monad type used from insert statement.fRun InsertStatement.efefefef2014-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357Cg/Type to accumulate query restrictions. Type cT is context tag of restriction building like Flat (where) or Aggregated (having).hLift to gMAdd whole query restriction.iRun g to get vN Resticted 6 instance.O Restricted ; instance.P Restricted 9 instance.Q@ instance. gRhMiNOPQghighigRhMiNOPQ2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357j<RestrictedStatement type synonym. Projection record type r must be the same as g type parameter r.kIRestrict only monad type used from update statement and delete statement.lRun k to get v.jkljklkjljkl2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357mAssignStatement type synonym. Specifying assignments and restrictions like update statement. Projection record type must be the same as Target type parameter r.nHTarget update monad type used from update statement and merge statement.oRun n.mnomnonmomno2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonep.InsertTarget type with place-holder parameter p and projection record type r.q.UpdateTarget type with place-holder parameter p and projection record type r.r-Restriction type with place-holder parameter p and projection record type r.s Finalize Restrict monad and generate r.t Finalize Restrict monad and generate r with place-holder parameter puSQL WHERE clause Y string from r.v Finalize Target monad and generate q.w Finalize Target monad and generate q with place-holder parameter p.xLift r to q . Update target columns are all.yLift r to q7. Update target columns are all. With placefolder type p.z Finalize Restrict monad and generate q . Update target columns are all.{ Finalize Restrict monad and generate q7. Update target columns are all. With placefolder type p.| SQL SET clause and WHERE clause Y string from q} Finalize e monad and generate p.~ Finalize Target monad and generate q with place-holder parameter p.SQL INSERT statement Y string from pSShow where clause.pTqUrVstWuvwXYxyz{|}~ZSpqrstuvwxyz{|}~rstqvwxyz{p}~u|pTqUrVstWuvwXYxyz{|}~ZS2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone3457C[) type to accumulate join product context.Lift to \%Unsafely update join product context.]"Add last join product restriction.(Unsafely join sub-query with this query.^#Basic monadic join operation using ;.Run  to get x_Joinable query instance. `\]Attribute maybe or just to joinResult joined context and  result projection.^_ab `\]^_ab2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone.OrderedQuery monad type with placeholder type p!. Projection must be the same as Y context type parameter c.PCore query monad type used from flat(not-aggregated) query and aggregated query.Extract  computation.2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone3457-Partition monad type for partition-by clause.Aggregated query type.  p r ==  ( p, w   r).Aggregated query monad type.Run  to get SQL with  computation.Run  to get  with  computation.?Operator to make window function result projection using built  monad.c Restricted @ instance. d to runResult SQL string with  computation to runResult  with  computationec dec2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357$Simple (not-aggregated) query type.  SimpleQuery' p r ==  ( p, w r).)Simple (not-aggregated) query monad type.%Lift from qualified table forms into .Run  to get SQL string with Qualify computation.Run  to get  with Qualify computation.f to runResult SQL string with Qualify computation SimpleQuery' to runResult  with Qualify computationf2014-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357CUnique query monad type./Unsafely join sub-query with this unique query.Run  SimpleQuery to get  with Qualify computation.gAttribute maybe or just to joinResult joined context and  result projection.h to runResult  with Qualify computationgh2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone4-/Unique relation type to compose scalar queries.9Restriction function type for direct style join operator.Simple  from h.Infered .Interface to derive h type object.$Join sub-query. Query result is not g. Join sub-query. Query result is g. The combinations of  and  express inner joins, left outer joins, right outer joins, and full outer joins. Here is an example of a right outer join:  outerJoin = relation $ do e <- queryMaybe employee d <- query department on $ e ?! E.deptId' .=. just (d ! D.deptId') return $ (,) |$| e |*| d List sub-query, for IN and EXIST with place-holder parameter p.List sub-query, for IN and EXIST. Finalize  monad and generate  with place-holder parameter p. Finalize  monad and generate . Finalize  monad and geneate  with place-holder parameter p. Finalize  monad and geneate .i9Basic direct join operation with place-holder parameters./Direct inner join with place-holder parameters.4Direct left outer join with place-holder parameters.5Direct right outer join with place-holder parameters.4Direct full outer join with place-holder parameters.jBasic 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.4Union of two relations with place-holder parameters.BUnion of two relations with place-holder parameters. Not distinct.:Subtraction of two relations with place-holder parameters.HSubtraction of two relations with place-holder parameters. Not distinct.;Intersection of two relations with place-holder parameters.IIntersection of two relations with place-holder parameters. Not distinct.!Unsafely specify unique relation.Discard unique attribute.k#Basic monadic join operation using ;.2Join unique sub-query with place-holder parameter p.2Join unique sub-query with place-holder parameter p. Query result is g. Finalize  monad and generate . Aggregated .-Scalar sub-query with place-holder parameter p.Scalar sub-query.4lmnoiLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationjLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relationpqrk**3lmnoijpqrk2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone3zUntype interface for typed no-result type statments 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  into untyped SQL query string.From  into typed  with suffix SQL words.From  into typed .Unsafely make typed  from SQL string. Make typed  from h and key columns selector . Make typed ( object using derived info specified by  type.Unsafely make typed  from SQL string.$Make untyped update SQL string from h and q. Make typed  from A, h and q. Make typed  using T, h and q. Make typed  from A, derived table and m Make typed  from T, derived table and m Make typed  from h and r!. Update target is all column.Directly make typed  from h and Restrict/ monad context. Update target is all column.Directly make typed  from h and Restrict/ monad context. Update target is all column.Statement to use chunked insertSize to use chunked insertUnsafely make typed + from single insert and chunked insert SQL.Unsafely make typed  from single insert SQL. Make typed  from h and columns selector  with configuration parameter. Make typed  from h and columns selector .Table type inferred . Make typed  from A, h and monadic builded p object. Make typed  from h and monadic builded p object. Make typed  from A$, derived table and monadic builded e object. Make typed  from T$, derived table and monadic builded e object.Unsafely make typed  from SQL string.+Make untyped insert select SQL string from h,  and . Make typed  from columns selector h,  and  with configuration parameter. Make typed  from columns selector h,  and .Table type inferred .Unsafely make typed  from SQL string.$Make untyped delete SQL string from h and r. Make typed  from A, h and r. Make typed  from h and r. Make typed  from A, derived table and RestrictContext Make typed  from T, derived table and RestrictContextsShow delete SQL stringtShow insert SQL string.uShow insert SQL string.vShow update SQL stringwShow update SQL stringxShow query SQL stringHQuery SQL to type Typed resultyRestrict monad contextz{|}~stuvwx<<9yz{|}~stuvwx 2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone4$Query restricted with specified key.+Query restricted with specified unique key.,Query restricted with specified primary key.+Query restricted with inferred primary key.Convert from Haskell type r into SQL value q" list expected by update form likeUPDATE  tableN SET c0 = ?, c1 = ?, ..., cn = ? WHERE key0 = ? AND key1 = ? AND key2 = ? ... using derived  RecordToSql proof object.Typed  using specified constraint key.Typed  using inferred primary key. inferred from table.-Unique key proof object which record type is a and key type is p. to add restriction.Result restricted -Unique key proof object which record type is a and key type is p. to add restriction.Result restricted .Primary key proof object which record type is a and key type is p. to add restriction.Result restricted  to add restriction.Result restricted h to updateKey with constraint c, record type r and columns type p Result typed Updateh 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 (2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneW  !"%&'(012;<=>?@ABCDEFGHIJKLMNOTfghw      !"#$%&'()*+,-./0123456789;>?@ABCDEFRSTUVWX[\]bceknpqrstuvwxyz{|}~!2015 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone4C:Arrow type corresponding to )*Arrow type corresponding to )+Arrow type corresponding to `Arrow type corresponding to Arrow type corresponding to YArrow type corresponding to I Arrow type corresponding to H Arrow type corresponding to J Arrow type corresponding to  Arrow type corresponding to  Arrow type corresponding to Arrow to build queries.Same as B. Arrow version.Same as C. Arrow version.Same as J. Arrow version. The result arrow is not injected by local projections.Same as N. Arrow version. The result arrow is not injected by any local projections.Same as >N. Arrow version. The result arrow is not injected by any local projections.Same as ?N. Arrow version. The result arrow is not injected by any local projections.Same as U. Arrow version. The result arrow is designed to be injected by local projections.Same as U. Arrow version. The result arrow is designed to be injected by local projections.Same as  to pass this result to ^ operator. Arrow version. The result arrow is designed to be injected by local projections.Same as  to pass this result to ^ operator. Arrow version. The result arrow is designed to be injected by local projections.Same as G. Arrow version. Useful for no reference cases to local projections.Same as G. Arrow version. Useful for no reference cases to local projections.Same as X. Arrow version. The result arrow is designed to be injected by any local projection.Same as X. Arrow version. The result arrow is designed to be injected by any local projection.Same as G. Arrow version. Useful for no reference cases to local projections.Same as G. Arrow version. Useful for no reference cases to local projections.Same as J. Arrow version. The result arrow is not injected by local projections. Same as J. Arrow version. The result arrow is not injected by local projections.!Same as Df. Arrow version. The result arrow is designed to be injected by local conditional flat-projections."Same as Ef. Arrow version. The result arrow is designed to be injected by local conditional flat-projections.#Same as Fl. Arrow version. The result arrow is designed to be injected by local conditional aggregated-projections.$Same as 7Z. Arrow version. The result arrow is designed to be injected by local flat-projections.%Same as j. Arrow version. The result arrow is designed to be injected by locally built arrow using placeholders.&Same as C. Finalize query-building arrow instead of query-building monad.'Same as C. Finalize query-building arrow instead of query-building monad.(Same as C. Finalize query-building arrow instead of query-building monad.)Same as C. Finalize query-building arrow instead of query-building monad.*Same as C. Finalize query-building arrow instead of query-building monad.+Same as 84. This arrow is designed to be injected by local 3.,Same as RE. This arrow is designed to be injected by local flat-projections.-Same as S4. This arrow is designed to be injected by local  AggregteKey..Same as T<. This arrow is designed to be injected by locally built  AggregtingSet arrow./Same as UE. This arrow is designed to be injected by local flat-projections.0Same as V. Finalize locally built .1Same as W. Finalize locally built .2Same as X. Finalize locally built  .3Same as [F. The result arrow is designed to be injected by local projections.4Same as \F. The result arrow is designed to be injected by local projections.5Same as ]F. The result arrow is designed to be injected by local projections.6Same as 5F. The result arrow is designed to be injected by local projections.7Same as 8. Make window function result projection using built  arrow.8Make _N into arrow which is designed to be injected by local projection assignees.9Same as  . Make 4 from assigning statement arrow using configuration.:Same as  . Make  from assigning statement arrow.;Same as  . Make 3 from restrict statement arrow using configuration.<Same as  . Make  from restrict statement arrow.B      !"#$%&'()*+,-./0123456789:;<f  !"%&'(012;<=>?@ABCDEFGHIJKLMNOTfghw      !"#$%&'()*+,-./0123469;@Abceknpqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<: !"#$%&'()*+,-./0123456789:;<     A      !"#$%&'()*+,-./0123456789:;<7"2013-2016 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone357@N$&Rule template to infer constraint key.=#Rule template to infer primary key.>#Rule template to infer primary key.?#Rule template to infer primary key.@$Rule template to infer not-null key.A$Rule template to infer not-null key.B$Rule template to infer not-null key.Column projection path  template.Column projection path  and constraint key template.CColumn projection path  templates.DSMake column projection path and constraint key templates using default naming rule.)Rule template to infer table derivations.4Template to define inferred entries from table type.Eh and  templates.FMake TableDerivationH variable expression template from table name using default naming rule.GMake hH variable expression template from table name using default naming rule.HMake J variable expression template from table name using specified naming rule.IMake H variable expression template from table name using default naming rule.JMake template for  instance.Make template for record & instance using specified naming rule.KLMake templates about table and column metadatas using specified naming rule.LJMake templates about table and column metadatas using default naming rule.MRMake templates about table, column and haskell record using specified naming rule.NPMake templates about table, column and haskell record using default naming rule.OTemplate of derived primary .PTemplate of derived primary Update.Q'SQL templates derived from primary key.RASQL templates derived from primary key using default naming rule. All templates about primary key.!All templates about not-null key.S>Generate all templtes about table using specified naming rule.T<Generate all templtes about table using default naming rule.UUnsafely inlining SQL string  in compile type.V8Extract param type and result type from defined RelationWInlining composed  in compile type.XnGenerate all templates against defined record like type constructor other than depending on sql-value type.(Constraint type Record typeKey typeIndexes specifies keyResult   declaration= Record typeKey typeIndexes specifies key"Result constraint key declarations>configuration parameters Schema name Table name Column typePrimary key index&Declarations of primary constraint key? Schema name Table name Column typePrimary key index&Declarations of primary constraint key@ Record type Column indexResult ColumnConstraint declarationAconfiguration parameters Schema name Table nameNotNull key index&Declaration of not-null constraint keyB Schema name Table nameNotNull key index&Declaration of not-null constraint key Record type Column declaration variable name0Column index expression in record (begin with 0) Column type"Column projection path declaration.May Constraint type and constraint object name Record type Column declaration variable name0Column index expression in record (begin with 0) Column type"Column projection path declarationCRecord type nameColumn info list#Column projection path declarationsDRecord type nameColumn info list#Column projection path declarationsTable declaration variable name"Relation declaration variable name*Insert statement declaration variable name/InsertQuery statement declaration variable name Record typeTable and Relation declarationETable declaration variable name"Relation declaration variable name*Insert statement declaration variable name/InsertQuery statement declaration variable name Record type'Table name in SQL ex. FOO_SCHEMA.table0 Column namesTable and Relation declarationFTable name stringResult var ExpGTable name stringResult var ExpH2Configuration which has naming rules of templatesSchema name stringTable name stringResult var ExpISchema name stringTable name stringResult var ExpJK$Configuration to generate query with Schema name Table name*Column names and types and constraint typeResult declarationsL$Configuration to generate query with Schema name Table name*Column names and types and constraint typeResult declarationsM$Configuration to generate query with Schema name Table nameColumn names and typesRecord derivingsResult declarationsN$Configuration to generate query with Schema name Table nameColumn names and typesRecord derivingsResult declarationsO#Variable name of result declarationParameter type of Record type of  expressionResult  declarationP#Variable name of result declarationParameter type of UpdateRecord type of Updateh expressionResult Update declarationQ9Variable name of select query definition from primary key=Variable name of update statement definition from primary keyPrimary key type Record typeRelation expressionTable expressionResult declarationsRTable name of DatabasePrimary key type Record typeRelation expressionTable expressionResult declarations Schema nameTable name stringType of primary keyIndexes specifies primary keyResult declarationsS$Configuration to generate query withSchema name string of DatabaseTable name string of DatabaseColumn names and typesderivings for Record typePrimary key indexNot null key indexResult declarationsT$Configuration to generate query withSchema name string of DatabaseTable name string of DatabaseColumn names and typesderivings for Record typePrimary key indexNot null key indexResult declarationsUQuery parameter typeQuery result typeSQL string query to inlineVariable name for inlined queryResult declarationsV%Variable name which has Relation type7Extracted param type and result type from Relation typeW"Top-level variable name which has  typeObject which has  typeConfiguration to generate SQLsuffix SQL words(Variable name to define as inlined queryResult declarationsXType constructor nameResult declaration=>?@ABCDEFGHIJKLMNOPQRSTUVWXSTUWMN=>?@ABCDEKLOPFGHIQRJXV(=>?@ABCDEFGHIJKLMNOPQRSTUVWX,-.,-/,-0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~C$$$$$$$$$$$ C     C G A B        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*+         !*!+!!!{!k!j!l!!!!!d!e!!!`!a!!!!!!!!!!!!!f!g!h!Y!<!!!!!!Z!t!u!v!w!x!y!z!}!~!!W!!!!! ! """""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6#7#89:;#<#=#>#?#@ABCDEF9:GHIJKLIMNOIMPQIRSTIUVWXYZ[XY\]XY^_XY`abcdebfdghijkhljmnXYop9qrs9qtu9qvw9qxyz{|}~9:,?C,-Pacdo}$$$$$$$$$9:$$$$$$$$G$$$$$$9$8$$$$$      D                    %%%%%%%&&&&&&''''          9:9:    q { !"#$%&'()*+,-./012.3456789:;<=>?@ABCD!!E!F!G!H!I!J!K"L"M"N"O"P"Q"R"S"T"U"V"WXrelat_Ja9quI1LeUZ9jjvTl42EjY$Database.Relational.Query.Constraint Database.Relational.Query.Scalar!Database.Relational.Query.ContextDatabase.Relational.Query.Pure#Database.Relational.Query.Pi.UnsafeDatabase.Relational.Query.Pi#Database.Relational.Query.ComponentDatabase.Relational.Query.TableDatabase.Relational.Query.Sub,Database.Relational.Query.Monad.Trans.Config(Database.Relational.Query.Monad.BaseType$Database.Relational.Query.ProjectionDatabase.Relational.Query.SQL%Database.Relational.Query.Projectable-Database.Relational.Query.ProjectableExtended%Database.Relational.Query.Monad.Class1Database.Relational.Query.Monad.Trans.Aggregating.Database.Relational.Query.Monad.Trans.Ordering/Database.Relational.Query.Monad.Trans.Assigning(Database.Relational.Query.Monad.Register1Database.Relational.Query.Monad.Trans.Restricting(Database.Relational.Query.Monad.Restrict&Database.Relational.Query.Monad.Assign Database.Relational.Query.Effect*Database.Relational.Query.Monad.Trans.Join$Database.Relational.Query.Monad.Type)Database.Relational.Query.Monad.Aggregate&Database.Relational.Query.Monad.Simple&Database.Relational.Query.Monad.Unique"Database.Relational.Query.RelationDatabase.Relational.Query.Type!Database.Relational.Query.DerivesDatabase.Relational.Query.ArrowDatabase.Relational.Query.TH&Database.Relational.Query.Internal.SQL&Database.Relational.Query.Internal.Sub-Database.Relational.Query.Monad.Trans.Qualify/Database.Relational.Query.Monad.Trans.JoinState*Database.Relational.Query.Internal.ProductDatabase.Relational.QueryMonadicRestrictedStatementAssignStatementpersi_Lh8oYK8jOmzLZUDzgzREP0Database.Record.KeyConstraintUniqueNotNullPrimary ScalarDegreedefineScalarDegreePowerSetListSet OverWindowExists AggregatedFlatShowConstantTermsSQLshowConstantTermsSQL'ProductConstructorproductConstructorshowConstantTermsSQLPiunsafeExpandIndexespfmappapwidth<.>pidefinePidefineDirectPi'defineDirectPiid'fst'snd'HasConstraintKey constraintKeyKeyindexesunsafeDefineConstraintKeytableConstraint projectionKey uniqueKeyderivedUniqueKey Assignments Assignment AssignTerm AssignColumn OrderingTerms OrderingTerm OrderColumnOrderAscDesc AggregateKey AggregateElem AggregateSetAggregateBitKeyAggregateColumnRef DuplicationAllDistinctIdentifierQuotation NoQuotation QuotationProductUnitSupport PUSupportedPUNotSupportedConfigproductUnitSupportchunksInsertSizeschemaNameModenormalizedTableNameverboseAsCompilerWarning nameConfigidentifierQuotationSchemaNameModeSchemaQualifiedSchemaNotQualified NameConfig recordConfigrelationVarName ColumnSQL columnSQL columnSQL'showsColumnSQL defaultConfigshowsDuplicationaggregateColumnRefaggregatePowerKeyaggregateGroupingSetaggregateRollup aggregateCube aggregateSetsaggregateEmptycomposeGroupBycomposePartitionByaggregateKeyProjectionaggregateKeyElementunsafeAggregateKeycomposeOrderBy composeSets composeValues composeOverTableDerivable derivedTableTableUntypedname'width'columns'!unTypename shortNamecolumnsindextoMaybetableQueryRestriction Projection JoinProductProductBuilderNodeAttrUntypedProjectionProjectionUnit Qualified QualifierSubQuery fromTable flatSubQueryaggregatedSubQueryunionexcept intersectunitSQLshowSQLtoSQL qualifier unQualifyqualify queryWidthcolumnuntypedProjectionFromColumns#untypedProjectionFromScalarSubQuery#untypedProjectionFromJoinedSubQuerywidthOfUntypedProjectioncolumnsOfUntypedProjectionprojectionColumnsunsafeProjectionStringSqlunsafeProjectFromColumnsnodeTree composeWhere composeHaving QueryConfigrunQueryConfig queryConfigaskQueryConfigRelationConfigureQueryconfigureQuery qualifyQuery askConfigunsafeTypeRelationuntypeRelationrightPhleftPhsqlFromRelationWithsqlFromRelationdumpListProjectionunsafeStringSqluntypeunsafeFromQualifiedSubQueryunsafeFromScalarSubQueryunsafeFromTableunsafeFromSqlTermspiMaybepiMaybe' flattenMaybejustunsafeChangeContextunsafeToAggregated unsafeToFlatunsafeStringSqlNotNullMaybelistunsafeListFromSubQueryunsafeStringSqlList QuerySuffixshowsQuerySuffixupdatePrefixSQL updateSQL'updateOtherThanKeySQL'updateOtherThanKeySQLinsertPrefixSQLinsertSizedChunkSQL insertSQLdeletePrefixSQL'deletePrefixSQLProjectableApplicative|*|ProjectableFunctor|$|ProjectableIdZipleftIdrightIdProjectableMaybe PlaceHoldersSqlBinOpProjectableShowSqlunsafeShowSql'SqlProjectableunsafeProjectSqlTerms'unsafeProjectSqlTermsunsafeProjectSql'unsafeProjectSqlunsafeValueNullvalue valueTrue valueFalsevalues unsafeShowSql unsafeUniOp unsafeBinOp.=..<..<=..>..>=..<>.and'or'not'exists.||.?||?like' likeMaybe'like likeMaybe.+..-../..*.negate' fromIntegral'showNum?+??-??/??*? negateMaybefromIntegralMaybe showNumMaybe caseSearch casesOrElsecaseSearchMaybecase' casesOrElse' caseMaybein' isNothingisJust fromMayberank denseRank rowNumber percentRankcumeDistunsafeAddPlaceHoldersunsafePlaceHoldersunitPlaceHolder placeholder' placeholder projectZip><ipfmapProjectableRunIdsZiprunIdsProjectableFlattenMaybeflattenunsafeAggregateOpcountsumMaybesum'avgMaybeavgmaxMaybemax'minMaybemin'everyany'some'?!?!?flattenPiMaybe!?? flattenPhMonadPartition partitionByMonadAggregategroupBygroupBy' MonadQualify liftQualify MonadQuerysetDuplication restrictJoinquery' queryMaybe' MonadRestrictrestrictall'distinctonwhereshavingPartitioningSetAggregatingSetListAggregatingPowerSetAggregatingSetPartitioningSetTAggregatingPowerSetTAggregatingSetListTAggregatingSetT Aggregatings aggregatingsextractAggregateTermskeykey'setbkeyrollupcube groupingSets Orderings orderingsorderByascdescextractOrderingTerms AssignTarget Assignings assigningsassignTo<-#extractAssignmentsRegisterextract Restrictings restrictingsextractRestrictRestrictAssign InsertTarget UpdateTarget Restriction restriction restriction'sqlWhereFromRestriction updateTarget updateTarget'liftTargetAllColumnliftTargetAllColumn'updateTargetAllColumnupdateTargetAllColumn'sqlFromUpdateTarget insertTarget insertTarget'sqlFromInsertTarget QueryJoinjoin'unsafeSubQueryWithAttrextractProduct OrderedQuery QueryCore extractCoreWindowAggregatedQueryQueryAggregate toSubQueryover SimpleQuery QuerySimplesimple QueryUniqueunsafeUniqueSubQueryUniqueRelationJoinRestrictionderivedRelationtableOfquery queryMaybe queryList' queryList relation'relationaggregateRelation'aggregateRelationinner'left'right'full'innerleftrightfullon'unionAll exceptAll intersectAllunion' unionAll'except' exceptAll' intersect' intersectAll' unsafeUniqueunUnique uniqueQuery'uniqueQueryMaybe'uniqueRelation'aggregatedUnique queryScalar' queryScalarUntypeableNoFetch untypeNoFetchDelete untypeDelete InsertQueryuntypeInsertQueryInsert untypeInsert chunkedInsertUpdate untypeUpdate KeyUpdate updateKeyuntypeKeyUpdateQuery untypeQueryunsafeTypedQueryrelationalQuerySQLrelationalQuery'relationalQueryunsafeTypedKeyUpdatetypedKeyUpdatetypedKeyUpdateTableunsafeTypedUpdate updateSQL typedUpdate' typedUpdatederivedUpdate' derivedUpdatetypedUpdateAllColumnrestrictedUpdateAllColumnrestrictedUpdateTableAllColumnuntypeChunkInsertchunkSizeOfInsertunsafeTypedInsert'unsafeTypedInsert typedInsert' typedInsert derivedInserttypedInsertValue'typedInsertValuederivedInsertValue'derivedInsertValueunsafeTypedInsertQueryinsertQuerySQLtypedInsertQuery'typedInsertQueryderivedInsertQueryunsafeTypedDelete deleteSQL typedDelete' typedDeletederivedDelete' derivedDelete specifiedKeyuniqueprimary'primaryupdateValuesWithKeyupdateByConstraintKey primaryUpdatederivedUniqueRelationQueryA queryExists queryExists' queryListU queryListU' queryScalarU queryScalarU'assigndefineHasPrimaryKeyInstance%defineHasPrimaryKeyInstanceWithConfig"defineHasPrimaryKeyInstanceDefaultdefineHasNotNullKeyInstance%defineHasNotNullKeyInstanceWithConfig"defineHasNotNullKeyInstanceDefault defineColumnsdefineColumnsDefaultdefineTableTypesderivationExpDefaulttableVarExpDefaultrelationVarExprelationVarExpDefault defineProductConstructorInstancedefineTableTypesWithConfigdefineTableTypesDefaultdefineTableTypesAndRecord defineTableTypesAndRecordDefaultdefinePrimaryQuerydefinePrimaryUpdatedefineSqlsWithPrimaryKeydefineSqlsWithPrimaryKeyDefault defineTabledefineTableDefaultunsafeInlineQuery reifyRelation inlineQuerymakeRelationalRecordDefault StringSQL stringSQLbaseGHC.BaseString showStringSQL rowStringSQLrowPlaceHolderStringSQLrowConsStringSQL listStringSQL$fScalarDegreeMaybe intExprSQLescapeStringToSqlExpr stringExprSQL$fShowConstantTermsSQL(,)$fShowConstantTermsSQLMaybeMaybe$fShowConstantTermsSQLUTCTimetime_FTheb6LSxyX1UABIbBXRfnData.Time.Clock.UTCUTCTime$fShowConstantTermsSQLZonedTimeData.Time.LocalTime.LocalTime ZonedTime$fShowConstantTermsSQLLocalTime LocalTime$fShowConstantTermsSQLTimeOfDayData.Time.LocalTime.TimeOfDay TimeOfDay$fShowConstantTermsSQLDayData.Time.Calendar.DaysDay$fShowConstantTermsSQLDoubleghc-prim GHC.TypesDouble$fShowConstantTermsSQLFloatFloat$fShowConstantTermsSQLBoolBool$fShowConstantTermsSQLCharChar$fShowConstantTermsSQLTexttext_HmqVQnZSpjaC156ABqPhneData.Text.Internal.LazyText$fShowConstantTermsSQLText0Data.Text.Internal $fShowConstantTermsSQLByteStringbytes_6VWy06pWzJq9evDvK2d4w6Data.ByteString.Lazy.Internal ByteString!$fShowConstantTermsSQLByteString0Data.ByteString.Internal$fShowConstantTermsSQL[]$fShowConstantTermsSQLIntInt$fShowConstantTermsSQLInt64GHC.IntInt64$fShowConstantTermsSQLInt32Int32$fShowConstantTermsSQLInt16Int16$fShowConstantTermsSQLInt8Int8$fProductConstructor(->) intTermsSQLstringTermsSQL floatTermsconstantTimeTermsshowMaybeTermsPi'unsafeCastRecordWidthmap definePi'Database.Record.PersistablePersistableRecordWidthLeftestMapunsafePiAppend'unsafePiAppend unsafeCastsnd'' KeyConstraintunsafeReturnKey mapConstraint ColumnSQL'stringFromColumnSQL ColumnRefRollupCube GroupingSetsshowsAggregateColumnRefcommaedpCommashowsAggregateBitKey$fShowNameConfig$fShowColumnSQL'$fFunctorColumnSQL' columnArrayuntypeProjectionProductTreeBuilderQueryProductTreeNode ProductTreeBinOpSetOptypedProjection$fFunctorQualifiedFunctorLeafJoinQueryRestrictionBuilderQSJust'Columns NormalizedScalarBinUnionExcept IntersectfromTableToSQLfromTableToNormalizedSQL normalizedSQLtoSQLs showQualifier columnFromIdqualifiedSQLas qualifiedFormwidthOfProjectionUnitcolumnOfProjectionUnitcolumnOfUntypedProjectionnodeAttrshowsQueryProductshowsJoinProductcomposeRestrict showsSetOp' showsSetOpsetBinselectPrefixSQL showUnitSQLcolumnN asColumnNprojectionUnitFromColumns projectionUnitFromScalarSubQueryunitUntypedProjectionQualifyevalQualifyPrimenewAliasAliasId JoinContextprimeJoinContext updateProduct joinProductproduct growRight growProductrestrictProduct'restrictProducttrans_GZTjP9K5WFq01xC9BAGQpFControl.Monad.Trans.ReaderReaderTunsafeCastPlaceHolder$fShowRelation unsafeProjectListSubnotNullMaybeConstraintinsertChunkSQL<*>fmap compareBinOp monoBinOp monoBinOp'unsafeCastPlaceHolders$fProjectableApplicativePi$fProjectableFunctorPi"$fProjectableApplicativeProjection$fProjectableFunctorProjection$$fProjectableApplicativePlaceHolders $fProjectableFunctorPlaceHolders$fProjectableIdZipPlaceHolders$fProjectableMaybeProjection$fProjectableMaybePlaceHolders$fProjectableShowSqlProjection$fSqlProjectableProjection$fSqlProjectableProjection0$fSqlProjectableProjection1OperatorProjectableunsafeFlatUniOp unsafeLikeunsafeCastProjectable whensClauseunsafeUniTermFunctionunsafeProjectPlaceHolder'unsafeProjectPlaceHolder$fOperatorProjectableProjection $fOperatorProjectableProjection0$fProjectableRunIdsZipaa$fProjectableRunIdsZip(,)b$fProjectableRunIdsZip(,)b0#$fProjectableFlattenMaybeMaybeMaybe$fProjectableFlattenMaybeMaybebAggregatedContext$fAggregatedContextOverWindow$fAggregatedContextAggregated$fMonadQualifyqq$fMonadPartitioncAggregatings$fMonadAggregateAggregatings$fMonadQueryAggregatings$fMonadQualifyqAggregatings$fMonadRestrictcAggregatingsunsafeAggregateWithTerm aggregateKeyextractTermList finalizePowerProjectableOrderingupdateOrderBys$fProjectableOrderingProjection$fMonadPartitioncOrderings$fMonadAggregateOrderings$fMonadQueryOrderings$fMonadQualifyqOrderings$fMonadRestrictrcOrderings orderTerms$fMonadQualifyqAssignings$fMonadRestrictcAssigningstargetProjectionupdateRestriction$fMonadAggregateRestrictings$fMonadQueryRestrictings$fMonadQualifyqRestrictings$fMonadRestrictcRestrictings$fShowRestrictionrunRestriction_runUpdateTargetupdateAllColumn$fShowUpdateTargetControl.Monad.Trans.State.LazyStateT updateContextupdateJoinRestriction queryWithAttr$fMonadQueryQueryJoin$fMonadQualifyqQueryJoin$fMonadTransQueryJoin$fMonadRestrictFlatRestrictings extractWindowjoin_uniqueQueryWithAttrplaceHoldersFromRelation queryList0 addUnitPHunsafeLiftAppend liftAppend liftAppend' $fShowDelete$fShowInsertQuery $fShowInsert $fShowUpdate$fShowKeyUpdate $fShowQuery targetTablerestrictedTable$fUntypeableNoFetchDelete$fUntypeableNoFetchUpdate$fUntypeableNoFetchInsertQuery$fUntypeableNoFetchInsertqueryA runQueryArunAofMunsafeQueryListunsafeQueryList'unsafeQueryScalarunsafeQueryScalar'defineHasConstraintKeyInstancecolumnTemplate'columnTemplatedefineTableDerivableInstancedefineTableDerivations*defineProductConstructorInstanceWithConfigdefineWithPrimaryKeydefineWithNotNullKeyWithConfigtableSQLquotederivationVarNameDefaulttableVarNameDefault