wE      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG H I J K L M NOPQRSTUVWXYZ[\]^_`abcd e f g h i j klmn o p q r s t u v 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"Y"Z"["\"]"^"_"`"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${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%02013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;*Constraint which represents scalar degree. instance templates.&2014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe9;!String wrap type for SQL strings. from . to .Row String of SQL values.Place holder row String of SQL.List String of SQL.List String of SQL.'2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeUntyped typed table typeName string of table in SQLWidth of tableColumn name strings in SQLColumn name strings in SQL,Column name string in SQL specified by index Column indexColumn name String in SQL2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone6:QR  aI is implicit rule to derive function to convert from haskell record type a into constant SQL terms.Generic programming ( ehttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming*) with default signature is available for , class, so you can make instance like below:  {-# LANGUAGE DeriveGeneric #-} import GHC.Generics (Generic) -- data Foo = Foo { ... } deriving Generic instance ShowConstantTermsSQL Foo *Weaken applicative functor on projections.  Method like . Weaken functor on projections.  Method like . CSpecify tuple like record constructors which are allowed to define  .The constructor which has type r.Same as  . other than using inferred record constructor..Convert from haskell record to SQL terms list.          4 42013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone:ATProjection 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.  phantom functor is -ed.Compose projection path.  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 ."Compose projection path 6 which has record result type using applicative style.# Compose seed of projection path  which has record result type.Index of flat SQL value listResult projection pathIndex of flat SQL value listResult projection path Indexes of flat SQL value listResult projection path!Indexes of flat SQL value listResult projection path"#  !  ! !"#8882013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone$Identity projection path.%!Projection path for fst of tuple.&!Projection path for snd of tuple.$%Projection path of fst.&Projection path of snd. $%& $%&$%&2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;Constant integral SQL terms.Escape $ for constant SQL string expression.From % into constant SQL string expression.'Constant SQL terms of # type. Width inference is required.(Constant SQL terms of T. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal with UTC timezone.)Constant SQL terms of B. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal.*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 .0Constant SQL terms of .1Constant SQL terms of .2Constant SQL terms of .3Constant SQL terms of .4Constant SQL terms of .5Constant SQL terms of .6Constant SQL terms of U. Use this carefully, because this is architecture dependent size of integer type.7Constant SQL terms of .8Constant SQL terms of .9Constant SQL terms of .:Constant SQL terms of .'()*+,-./0123456789:'()*+,-./0123456789:2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone ;Inference rule of = existence.=Phantom typed table type> Untype table.?Name string of table in SQL@)Not qualified name string of table in SQLAWidth of tableBColumn name strings in SQLC,Column name string in SQL specified by indexDCast phantom type into  type.E+Unsafely generate phantom typed table type. ;<=>?@ABC Column indexColumn name String in SQLDE ;<=>?@ABCDE =>?@ABCED;< ;<=>?@ABCDE(2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeFTypeful aggregate element.Type for group-by treeType for grouping setType for group key.Type for group-by term Single term aggregation element.Key of aggregation power set.Single grouping set. Rollup aggregation element. Cube 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 F.Extract untyped term from F.5Unsafely bind typed-projection and untyped-term into F.F     F     F     )2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeG#Type tag for aggregatings power setH'Type tag for aggregatings GROUPING SETSI$Type tag for normal aggregatings setJ%Type tag for window function buildingKType tag for exists predicateLType tag for aggregated queryM(Type tag for flat (not-aggregated) queryGHIJKLMGHIJKLMGHIJKLM*2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneNConfiguration type.V2Configuration for quotation of identifiers of SQL.Y'Schema name qualify mode in SQL string.Z)Schema qualified table name in SQL string[&Not qualified table name in SQL string\$Unit of product is supported or not.__/ type to customize names of expanded templates.cDefault configuration.NOPQRSTUVWXYZ[\]^_`abcNOPQRSTUVWXYZ[\]^_`abcNOPQRSTUVWXYZ[\]^_`abc 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneId. type to require query generate configuration.eRun d to expand with configurationfLift to d.gRead configuration.defgdefgdfegdefg+2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe  Assignment pair!Value SQL String of assignment"Column SQL String of assignment#Type for order-by term$Type for order-by columnk)Order direction. Ascendant or Descendant.%#Result record duplication attribute&%Compose duplication attribute string.'*Compose ORDER BY clause from OrderingTerms(Compose SET clause from [ ].)1Compose VALUES clause from value expression list.*1Compose VALUES clause from value expression list. !"#$klm%+,&'()record count per chunkvalue expression list*record count per chunk !"#$klm%+,&'()*  !"#$klm%+,&'()*,2015-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone234#nType for restriction of query.o=Phantom typed projection. Projected into Haskell record type t.-Discard projection value type p'Untyped projection. Forgot record type.q2Projection structure unit with single column width.,used in immediate value or unsafe operations/ normalized sub-query reference T n with Int index0scalar sub-query1 nth column of case clause2 case clause3 when clausesrType for join product of query.s*Product noe with join restriction builder.4+Product tree with join restriction builder.5#Product tree with join restriction.6.Product node. node attribute and product tree.7KProduct tree type. Product tree is constructed by left node and right node.tnode attribute for product.wQualified query.xQualifier type.zSub-query type8Set binary operators9 Set operators: Get qualifier; Unqualify.< Add qualifier=Get node attribute.>Get tree from node.? Width of p.@Unsafely type projection value.A Width of o.BUnsafely generate o from SQL string list.CUnsafely generate o from scalar sub-query.D.Search case operator correnponding SQL search CASE . Like, 1CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c ENDE.Simple case operator correnponding SQL simple CASE . Like, 1CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END9noF-pq./012GH3Irs456J7KLMNtuvwOxyzPQRS8T9UVW:;<=>?@AB!SQL string list specifies columnsResult oCX Error tagEach when clausesElse result projection Result clauseDEach when clausesElse result projectionResult projectionEProjection value to matchEach when clausesElse result projectionResult projection5no-pq0./12GH3Irs456J7KLtvuwOxyzPSRQ8T9UVW:;<=>?@ABCDE!noF-pq./012GH3Irs456J7KLMNtuvwOxyzPQRS8T9UVW:;<=>?@ABCXDE-2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneY&Push new tree into product right term.Z+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.Y Current treeNew tree to push into right Result nodeZ Current treeNew leaf to push into right Result node[Product to restrictRestriction to addResult product\)Target node which has product to restrictRestriction to add Result nodeZ\YZ[\.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone]JoinContext type for QueryJoin.^Initial ]._Update product of ].`6Finalize context to extract accumulated query product.]ab^_`]^_`]ab^_`/2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneIc&Monad type to qualify SQL table forms.d8Run qualify monad with initial state to get only result.e*Generated new qualifier on internal state.fLift to cgGet qualifyed table form query.chdefgQuery to qualifyResult with updated statecdfgchdefg 2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeGHIJKLMMLKJIHG 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone {z from =.|Unsafely generate flat z from untyped components.}Unsafely generate aggregated z from untyped components.~Union binary operator on zExcept binary operator on zIntersect binary operator on z Width of z.iSQL to query table.j*Generate normalized column SQL from table.kNormalized column SQLl-SQL string for nested-query and toplevel-SQL.SQL string for nested-qeury.SQL StringSQL for toplevel-SQL.SQL string for toplevel-SQL.mAlias string from qualifiernBinary operator to qualify.o9Qualified expression from qualifier and projection index.pFrom w" SQL string into qualified formed  like (SELECT ...) AS T n Width of w SubQUery.Get column SQL string of z..Make untyped projection from joined sub-query.q1index result of each when clause and else clause.r1index result of each when clause and else clause.s(Convert from ProjectionUnit into column.tGet column SQL string of p.)Get column SQL string list of projection.Unsafely get SQL term from  Proejction.u6Show product tree of query into SQL. StringSQL result.vShows join product of query.wCompose SQL String from n.Compose WHERE clause from n.Compose HAVING clause from n.'xy{Typed = metadataResult z|}z~ijk{lsub-query SQL and top-level SQL|}~mnopqrstSource o Column indexResult SQL stringSource oResult SQL string listuvwnopqrstvuwxyz{|}~z{|}~xywoqprtuvsn'xy{|}z~ijk{l|}~mnopqrstuvw 2015-2017 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-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone:Projection type for row list.Unsafely get SQL term from  Proejction.)Get column SQL string list of projection. Width of o. Unsafely get untyped projection.Unsafely generate o# from qualified (joined) sub-query.Unsafely generate o from scalar sub-query.Unsafely generate unqualified o from =.Unsafely generate o from SQL expression strings.Unsafely trace projection path.&Trace projection path to get narrower o.&Trace projection path to get narrower o. From  type to  type.&Trace projection path to get narrower o. 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 o type.Projectable ap of o type.Make row list projection from o list.Make row list projection from z.IMap projection show operatoions and concatinate to single SQL expression.Compose record type o using applicative style.Compose seed of record type o.Source oResult SQL string listSource oProjection path Narrower oSource o.  typeProjection path Narrower o.  type resultSource o.  typeProjection path.  type leaf Narrower o.  type resultoo2013-2017 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 SQLRecords 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-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=  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  Inferred  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-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneFNOPRQUTSVWXYZ[\]^_`abcklm_`ab\]^YZ[VWXNOPQRSTUcFklm2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone*9;Make template for   instance.;Make template of ProductConstructor instance of tuple type.Make template of  instance of tuple type.3Make templates of projection paths for tuple types.2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;T'2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;X)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 term from projection object.(Interface to project SQL terms unsafely.+Unsafely project from SQL expression terms.!Unsafely Project single SQL term.8Unsafely Project single SQL string. String interface of .KPolymorphic projection of SQL null value. Semantics of comparing is unsafe.5Deprecated. 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 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.0RANK() term.1 DENSE_RANK() term.2 ROW_NUMBER() term.3PERCENT_RANK() term.4 CUME_DIST() term.5.Unsafely add placeholder parameter to queries.6"Unsafely get placeholder parameter7No placeholder semantics8"No placeholder semantics. Same as 7)Unsafely cast placeholder parameter type.9FProvide scoped placeholder from width and return its parameter object.:;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 <.>Compose record type  using applicative style.?Compose seed of record type .@LZipping except for identity element laws against placeholder parameter type.AControl phantom  type in projection type o.BControl phantom  type in placeholder parameters.CUnsafely get SQL term from  Proejction.FUnsafely make o from SQL terms.GUnsafely make o from SQL terms.HUnsafely make o from SQL terms.bSource projection objectResult SQL expression string.      !"#$%&Each when clausesElse result projectionResult projection'Each when clausesElse result projectionResult projection(Each 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,-./0123456789:;<=>?@ABCDEFGHM      !"#$%&'()*+,-./0123456789:;<=M569:;78     , "!-./#$%'*&()+01234<=[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH4 4 4 4 4 43255444466776 6!7"7,4=12013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=I(Window specification building interface.JAdd  PARTITION BY term into context.K,Aggregated query building interface extends P.LAdd GROUP BY1 term into context and get aggregated projection.N'Lift interface from base qualify monad.OLift from qualify monad q into P* m. Qualify monad qualifies table form SubQuery.PQuery building interface.QSpecify duplication.RAdd restriction to last join.S+Join sub-query with place-holder parameter p. query result is not .T+Join sub-query with place-holder parameter p. Query result is .URestrict context interfaceV Add restriction to this context.W'Specify ALL attribute to query context.X,Specify DISTINCT attribute to query context.Y6Add restriction to last join. Projection type version.Z-Add restriction to this not aggregated query.[MAdd restriction to this aggregated query. Aggregated Projection type version.IJKLMNOPQRSTUVWXYZ[\IJKLMNOPSTQRUVWXYZ[NOUVPQRSTKLMIJWXYZ[ IJKLMNOPQRSTUVWXYZ[\2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=I]/Context monad type to build partition keys set.^.Context monad type to build grouping set list._/Context monad type to build grouping power set.`0Context monad type to build single grouping set.a)Context type building partition keys set.b&Context type building power group set.c)Context type building grouping sets list.d'Context type building one grouping set.e0Type 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.fLift to e.gRun e to get terms list.h3Specify key of single grouping set from Projection.i#Specify key of single grouping set.j)Finalize and specify single grouping set.k)Specify key of rollup and cube power set.l0Finalize grouping power set as rollup power set.m.Finalize grouping power set as cube power set.nFinalize grouping set list.oPartition clause instancepAggregated query instance.q Aggregated P.r Aggregated N.s Aggregated U.]^_`abcdefghijklmnopqrs]^_`abcdefghijklmnefdcbag`_^]hijklmn]^_`abcdefghijklmnopqrs2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=IxTarget of assignment.y.Type to accumulate assigning context. Type r is table record type.zLift to y{Add an assignment.|Add and assginment.}Run y to get  Assignments~N with assigning.U with assigning. xyz{|}~xyz{|}yz{|x} xyz{|}~|42015-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone6Target register monad type used from insert statement.Run InsertStatement.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=I(Ordering term projection type interface.-Type to accumulate ordering context. Type c* is ordering term projection context type.Lift to .Add ordering terms.Add ordering terms.Add ascendant ordering term.Add descendant ordering term.Run  to get  OrderingTermso is ordering term.I with ordering.K with ordering.P with ordering.N with ordering.U with ordering.Order directionOrdering terms to addResult context with orderingOrdering terms to addOrder directionResult context with orderingOrdering terms to addResult context with orderingOrdering terms to addResult context with ordering2014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=I/Type to accumulate query restrictions. Type cT is context tag of restriction building like Flat (where) or Aggregated (having).Lift to Add whole query restriction.Run  to get n Resticted K instance. Restricted P instance. Restricted N instance.U instance. 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=<RestrictedStatement type synonym. Projection record type r must be the same as  type parameter r.IRestrict only monad type used from update statement and delete statement.Run  to get n.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=AssignStatement type synonym. Specifying assignments and restrictions like update statement. Projection record type must be the same as Target type parameter r.HTarget update monad type used from update statement and merge statement.Run .2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone.InsertTarget type with place-holder parameter p and projection record type r..UpdateTarget type with place-holder parameter p and projection record type r.-Restriction type with place-holder parameter p and projection record type r. Finalize Restrict monad and generate . Finalize Restrict monad and generate  with place-holder parameter pSQL 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 Restrict monad and generate  . Update target columns are all. Finalize Restrict monad and generate 7. Update target columns are all. With placefolder type p. SQL SET clause and WHERE clause  string from  Finalize  monad and generate . Finalize Target monad and generate  with place-holder parameter p.parametalized  monad from Make 2 string of SQL INSERT record chunk statement from Make % string of SQL INSERT statement from Show where clause.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=I) 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 P.Run  to get rJoinable query instance. Attribute maybe or justz to joinResult joined context and z result projection. 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone.OrderedQuery monad type with placeholder type p!. Projection must be the same as  context type parameter c.PCore query monad type used from flat(not-aggregated) query and aggregated query.Extract  computation.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=-Partition monad type for partition-by clause.Aggregated query type.  p r ==  ( p, o L r).Aggregated query monad type.Run  to get SQL with  computation.Run  to get z with  computation.?Operator to make window function result projection using built  monad. Restricted U instance.  to runResult SQL string with  computation to runResult z with  computation 82013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=$Simple (not-aggregated) query type.  SimpleQuery' p r ==  ( p, o r).)Simple (not-aggregated) query monad type.%Lift from qualified table forms into .Run  to get SQL string with Qualify computation.Run  to get z with Qualify computation. to runResult SQL string with Qualify computation SimpleQuery' to runResult z with Qualify computation2014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=IUnique query monad type./Unsafely join sub-query with this unique query.Run  SimpleQuery to get z with Qualify computation.Attribute maybe or justz to joinResult joined context and z result projection. to runResult z with Qualify computation 2013 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9:;<=3Interface to run recursively identity element laws.Interface to compose phantom  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  phantom functor is -ed.pGet narrower projection along with projection path and project into result projection type. Source record * phantom functor and projection path leaf  functor are join-ed.YGet 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. 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.Source projectionProjection pathNarrower projected objectSource o.  typeProjection pathNarrower projected object.  type resultSource o.  phantom typeProjection path.  type leafNarrower projected object.  phantom type resultSource o.  phantom typeProjection path Narrower o . Flatten  phantom typeSource o.  phantom typeProjection path&Narrower flatten and projected object.8888!2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone:-/Unique relation type to compose scalar queries.zRestriction predicate function type for direct style join operator, used on predicates of direct join style as follows. # do xy <- query $ relX   relY F [ x y -> ... ] -- this lambda form has JoinRestriction type ... Simple  from =. Inferred .Interface to derive = type object.$Join sub-query. Query result is not . Join sub-query. Query result is . 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 .9Basic 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.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.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.#Basic monadic join operation using P.2Join unique sub-query with place-holder parameter p.2Join unique sub-query with place-holder parameter p. Query result is .  Finalize  monad and generate .! Aggregated ."-Scalar sub-query with place-holder parameter p.#Scalar sub-query.4Left query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relation Left query to joinRight query to joinJoin restrictionsResult joined relation Left query to joinRight query to joinJoin restrictionsResult joined relation Left query to joinRight query to joinJoin restrictionsResult joined relation Left query to joinRight query to joinJoin restrictionsResult joined relation Left query to joinRight query to joinJoin restrictionsResult joined relationLeft query to joinRight query to joinJoin restrictionsResult joined relation !"#*      !"#* !#"     3      !"#88 8 8 8 8 888777788777788"2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone7$zUntype 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.0(Update type with place-holder parameter p.3Update 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.7'Query type with place-holder parameter p and query result type a.:Unsafely make typed 7 from SQL string.;From  into untyped SQL query string.<From  into typed 7 with suffix SQL words.=From  into typed 7.>Unsafely make typed 3 from SQL string.? Make typed 3 from = and key columns selector .@ Make typed 3( object using derived info specified by  type.A Make typed 3- from derived table and key columns selector .BUnsafely make typed 0 from SQL string.C$Make untyped update SQL string from = and .D Make typed 0 from N, = and .E Make typed 0 using c, = and .F Make typed 0 from N, derived table and G Make typed 0 from c, derived table and  Make typed 0 from N, = and !. Update target is all column.H Make typed 0 from = and !. Update target is all column.I Make typed 0 from N, derived table and !. Update target is all column.J Make typed 0 from c, derived table and !. Update target is all column.KDirectly make typed 0 from = and Restrict/ monad context. Update target is all column.LDirectly make typed 0 from = and Restrict/ monad context. Update target is all column.MStatement to use chunked insertNSize to use chunked insertOUnsafely make typed ,+ from single insert and chunked insert SQL.PUnsafely make typed , from single insert SQL.Q Make typed , from = and columns selector  with configuration parameter.R Make typed , from = and columns selector .STable type inferred ,.T Make typed , from N, = and monadic builded  object.U Make typed , from = and monadic builded  object.V Make typed , from N$, derived table and monadic builded  object.W Make typed , from c$, derived table and monadic builded  object.XUnsafely make typed ) from SQL string.Y+Make untyped insert select SQL string from =,  and .Z Make typed ) from columns selector =,  and  with configuration parameter.[ Make typed ) from columns selector =,  and .\Table type inferred ).]Unsafely make typed & from SQL string.^$Make untyped delete SQL string from = and ._ Make typed & from N, = and .` Make typed & from = and .a Make typed & from N, derived table and RestrictContextb Make typed & from c, derived table and RestrictContextgShow delete SQL stringhShow insert SQL string.iShow insert SQL string.jShow update SQL stringkShow update SQL stringlShow query SQL stringL$%&'()*+,-./0123456789:Query SQL to type Typed result;<=>?@ABCDEFGHIJKRestrict monad contextLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl?$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab?789:<=;3456>?@A012BDEFGHIJKLC,-./MNOPQRSTUVW)*+XZ[\Y&'(]_`ab^$%=$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl#2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone:m$Query restricted with specified key.n+Query restricted with specified unique key.o,Query restricted with specified primary key.p+Query restricted with inferred primary key.qConvert 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.rTyped 3 using specified constraint key.sTyped 3 using inferred primary key.t inferred from table.m-Unique key proof object which record type is a and key type is p. to add restriction.Result restricted n-Unique key proof object which record type is a and key type is p. to add restriction.Result restricted o.Primary key proof object which record type is a and key type is p. to add restriction.Result restricted p to add restriction.Result restricted qr= to updateKey with constraint c, record type r and columns type p Result typed Updates= to update Result typed Updatet-Unique key proof object which record type is a and key type is p.Unique key value to specify.Result restricted mnopqrstmnoprsqtmnopqrst02013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone{ $%&;<=FGHIJKLMNOPRQUTSVWXYZ[\]^_`abcklmoz      !"#$%&'()*+,-./0123456789:;<=IJKLMNPSTUVWXYZ[hijklmn{|      !"#$%&'()*+,-./0123456789;<=?@ACDEFGHIJKLMNOQRSTUVWYZ[\^_`abmnopqrst$2015-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone:I=uArrow type corresponding to 12vArrow type corresponding to wArrow type corresponding to 13xArrow type corresponding to yyArrow type corresponding to zArrow type corresponding to {Arrow type corresponding to _|Arrow type corresponding to ^}Arrow type corresponding to `~Arrow type corresponding to Arrow type corresponding to Arrow type corresponding to Arrow to build queries.Same as W. Arrow version.Same as X. 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 SN. Arrow version. The result arrow is not injected by any local projections.Same as TN. 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 Yf. Arrow version. The result arrow is designed to be injected by local conditional flat-projections.Same as Zf. Arrow version. The result arrow is designed to be injected by local conditional flat-projections.Same as [l. Arrow version. The result arrow is designed to be injected by local conditional aggregated-projections.Same as LZ. 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 M4. This arrow is designed to be injected by local F.Same as hE. This arrow is designed to be injected by local flat-projections.Same as i4. This arrow is designed to be injected by local  AggregteKey.Same as j<. This arrow is designed to be injected by locally built  AggregtingSet arrow.Same as kE. This arrow is designed to be injected by local flat-projections.Same as l. Finalize locally built {.Same as m. Finalize locally built {.Same as n. Finalize locally built |.Same as F. The result arrow is designed to be injected by local projections.Same as F. The result arrow is designed to be injected by local projections.Same as F. The result arrow is designed to be injected by local projections.Same as JF. The result arrow is designed to be injected by local projections.Same as 8. Make window function result projection using built y arrow.Make xN into arrow which is designed to be injected by local projection assignees.Same as F . Make 04 from assigning statement arrow using configuration.Same as G . Make 0 from assigning statement arrow.Same as V . Make ,) from register arrow using configuration.Same as W . Make , from register arrow.Same as a . Make 03 from restrict statement arrow using configuration.Same as b . Make 0 from restrict statement arrow.Euvwxyz{|}~ $%&;<=FGHIJKLMNOPRQUTSVWXYZ[\]^_`abcklmoz      !"#$%&'()*+,-./0123456789:<=IKNPUV{|     !$%&'()*+,-./0123456789;<=?@ACDEHIJKLMNOQRSTUYZ[\^_`mnopqrstuvwxyz{|}~=~}|{zyxwvuDuvwxyz{|}~8%2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone9;<=FT&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.Column projection path  template.Column projection path  and constraint key template.Column projection path  templates.SMake 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.= and  templates.Make TableDerivationH variable expression template from table name using default naming rule.Make =H variable expression template from table name using default naming rule.Make J variable expression template from table name using specified naming rule.Make template for record ProductConstructor& instance using specified naming rule.LMake templates about table and column metadatas using specified naming rule.RMake templates about table, column and haskell record using specified naming rule.Template of derived primary 7.Template of derived primary Update.'SQL templates derived from primary key.ASQL templates derived from primary key using default naming rule. All templates about primary key.!All templates about not-null key.>Generate all templtes about table using specified naming rule.Unsafely inlining SQL string 7 in compile type.8Extract param type and result type from defined RelationInlining composed 7 in compile type.nGenerate 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 declarationsconfiguration parameters Schema name Table name Column typePrimary key index&Declarations of primary constraint key Record type Column indexResult ColumnConstraint declarationconfiguration parameters 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 declarationRecord type nameColumn info list#Column projection path declarationsRecord 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 declarationTable 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 declarationTable name stringResult var ExpTable name stringResult var Exp2Configuration which has naming rules of templatesSchema name stringTable name stringResult var Exp$Configuration to generate query with Schema name Table name*Column names and types and constraint typeResult declarations$Configuration to generate query with Schema name Table nameColumn names and typesRecord derivingsResult declarations#Variable name of result declarationParameter type of 7Record type of 7 expressionResult 7 declaration#Variable name of result declarationParameter type of UpdateRecord type of Update= expressionResult Update declaration9Variable name of select query definition from primary key=Variable name of update statement definition from primary keyPrimary key type Record typeRelation expressionTable expressionResult declarationsTable name of DatabasePrimary key type Record typeRelation expressionTable expressionResult declarations Schema nameTable name stringType of primary keyIndexes specifies primary keyResult declarations$Configuration to generate query withSchema name string of DatabaseTable name string of DatabaseColumn names and typesderivings for Record typePrimary key indexNot null key indexResult declarationsQuery parameter typeQuery result typeSQL string query to inlineVariable name for inlined queryResult declarations%Variable name which has Relation type7Extracted param type and result type from Relation type"Top-level variable name which has  typeObject which has  typeConfiguration to generate SQLsuffix SQL words(Variable name to define as inlined queryResult declarationsType constructor nameResult declaration!4564574589:;&<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvPwxyz({)|)})~))))**********************  +++,,,,,,,,,,,,, P    w P T M N       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~23                              !!!z!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!!2!!3!!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B"C"D"E"E"F"G"G"H"I"I"J"K"L"L"M"N"N"O"P"Q"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"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"{"|"}"~"""""""########$2$$3$$$$$$$$$$$$$!$"$~$$$$#$$$$$B$A$$$=$>$$$$w$f$&$%$($'$?$x$$$$$$$$$$$u$$$_$`$o$p$z${$$%%%%%%%%%%%%%%%%%%%%%&&&&&&'''O''''4Ks((((((((((((((((({(((((((((** + + + + +++++++++,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,Q,T,,.,/,, ,0,1,2,3,,s,,,4,",5,6,7,8-9-:-;-<.=.>.?.@.=.A/B/C/D/&//B E F G H I Q J K L M N O P Q R S T U V W X Y  Z [ \ ]  ^_P45`abcdefgh"ijklmnopqrstuvwxyz{|}~ !!!!6!!!!!!"""$$$$$$$$%%%%%%%%%%%%/relational-query-0.9.2.0-8JdpvTerMVCLGdk7VGDzdb$Database.Relational.Query.Constraint Database.Relational.Query.Scalar*Database.Relational.Query.ProjectableClass#Database.Relational.Query.Pi.UnsafeDatabase.Relational.Query.PiDatabase.Relational.Query.PureDatabase.Relational.Query.Table#Database.Relational.Query.Component!Database.Relational.Query.Context,Database.Relational.Query.Monad.Trans.ConfigDatabase.Relational.Query.Sub(Database.Relational.Query.Monad.BaseType$Database.Relational.Query.ProjectionDatabase.Relational.Query.SQL Database.Relational.Query.BaseTH(Database.Relational.Query.TupleInstances%Database.Relational.Query.Projectable%Database.Relational.Query.Monad.Class1Database.Relational.Query.Monad.Trans.Aggregating/Database.Relational.Query.Monad.Trans.Assigning(Database.Relational.Query.Monad.Register.Database.Relational.Query.Monad.Trans.Ordering1Database.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.ProjectableExtended"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.UntypedTable.Database.Relational.Query.Internal.GroupingSQL.Database.Relational.Query.Internal.ContextType)Database.Relational.Query.Internal.Config*Database.Relational.Query.Internal.BaseSQL&Database.Relational.Query.Internal.Sub*Database.Relational.Query.Internal.Product/Database.Relational.Query.Monad.Trans.JoinState-Database.Relational.Query.Monad.Trans.QualifyDatabase.Relational.QueryMonadicRestrictedStatementAssignStatement1persistable-record-0.5.0.1-G438bUfgSFn3L489XvZi9ADatabase.Record.KeyConstraintUniqueNotNullPrimary ScalarDegreedefineScalarDegree$fScalarDegreeMaybe StringSQLShowConstantTermsSQLshowConstantTermsSQL'ProjectableApplicative|*|ProjectableFunctor|$|ProductConstructorproductConstructoripfmapshowConstantTermsSQL$fGShowConstantTermsSQLK1$fGShowConstantTermsSQLM1$fGShowConstantTermsSQL:*:$fGShowConstantTermsSQLU1PiunsafeExpandIndexespfmappapwidth'width<.>pidefinePidefineDirectPi'defineDirectPi$fProjectableApplicativePi$fProjectableFunctorPiid'fst'snd'$fShowConstantTermsSQLMaybe$fShowConstantTermsSQLUTCTime$fShowConstantTermsSQLZonedTime$fShowConstantTermsSQLLocalTime$fShowConstantTermsSQLTimeOfDay$fShowConstantTermsSQLDay$fShowConstantTermsSQLDouble$fShowConstantTermsSQLFloat$fShowConstantTermsSQLBool$fShowConstantTermsSQLChar$fShowConstantTermsSQLText$fShowConstantTermsSQLText0 $fShowConstantTermsSQLByteString!$fShowConstantTermsSQLByteString0$fShowConstantTermsSQL[]$fShowConstantTermsSQLInt$fShowConstantTermsSQLInt64$fShowConstantTermsSQLInt32$fShowConstantTermsSQLInt16$fShowConstantTermsSQLInt8TableDerivable derivedTableTableunTypename shortNamecolumnsindextoMaybetable AggregateKeyPowerSetListSet OverWindowExists AggregatedFlatConfigproductUnitSupportchunksInsertSizeschemaNameModenormalizedTableNameverboseAsCompilerWarningidentifierQuotation nameConfigIdentifierQuotation NoQuotation QuotationSchemaNameModeSchemaQualifiedSchemaNotQualifiedProductUnitSupport PUSupportedPUNotSupported NameConfig recordConfigrelationVarName defaultConfig QueryConfigrunQueryConfig queryConfigaskQueryConfig$fMonadQueryConfig$fFunctorQueryConfig$fApplicativeQueryConfigOrderAscDescQueryRestriction ProjectionUntypedProjectionProjectionUnit JoinProductProductBuilderNodeAttrJust'Maybe Qualified QualifierSubQuery fromTable flatSubQueryaggregatedSubQueryunionexcept intersectunitSQLshowSQLtoSQL queryWidthcolumn#untypedProjectionFromJoinedSubQueryprojectionColumnsunsafeProjectionStringSql composeWhere composeHavingRelationConfigureQueryconfigureQuery qualifyQuery askConfigunsafeTypeRelationuntypeRelationrightPhleftPhsqlFromRelationWithsqlFromRelationdump$fShowRelationListProjectionunsafeStringSqluntypeunsafeFromQualifiedSubQueryunsafeFromScalarSubQueryunsafeFromTableunsafeFromSqlTermspiMaybepiMaybe' flattenMaybejustunsafeChangeContextunsafeToAggregated unsafeToFlatunsafeStringSqlNotNullMaybelistunsafeListFromSubQueryunsafeStringSqlList"$fProjectableApplicativeProjection$fProjectableFunctorProjection QuerySuffixshowsQuerySuffixupdatePrefixSQL updateSQL'updateOtherThanKeySQL'updateOtherThanKeySQLinsertPrefixSQLinsertSizedChunkSQL insertSQLdeletePrefixSQL'deletePrefixSQLHasConstraintKey constraintKeyKeyindexesunsafeDefineConstraintKeytableConstraint projectionKey uniqueKeyderivedUniqueKey defineProductConstructorInstancedefineTupleProductConstructordefineTupleShowConstantInstance defineTuplePi$fProductConstructor(->)$fProductConstructor(->)0$fProductConstructor(->)1$fProductConstructor(->)2$fProductConstructor(->)3$fProductConstructor(->)4 tuplePi2_0' tuplePi2_1' tuplePi3_0' tuplePi3_1' tuplePi3_2' tuplePi4_0' tuplePi4_1' tuplePi4_2' tuplePi4_3' tuplePi5_0' tuplePi5_1' tuplePi5_2' tuplePi5_3' tuplePi5_4' tuplePi6_0' tuplePi6_1' tuplePi6_2' tuplePi6_3' tuplePi6_4' tuplePi6_5' tuplePi7_0' tuplePi7_1' tuplePi7_2' tuplePi7_3' tuplePi7_4' tuplePi7_5' tuplePi7_6'$fShowConstantTermsSQL(,,,,,,)$fShowConstantTermsSQL(,,,,,)$fShowConstantTermsSQL(,,,,)$fShowConstantTermsSQL(,,,)$fShowConstantTermsSQL(,,)$fShowConstantTermsSQL(,)ProjectableIdZipleftIdrightIdProjectableMaybe PlaceHoldersSqlBinOpProjectableShowSqlunsafeShowSql'SqlProjectableunsafeProjectSqlTermsunsafeProjectSql'unsafeProjectSqlnothingunsafeValueNullvalue 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 percentRankcumeDistunsafeAddPlaceHoldersunsafePlaceHoldersunitPlaceHolderunitPH pwPlaceholder placeholder' placeholder projectZip><$$fProjectableApplicativePlaceHolders $fProjectableFunctorPlaceHolders$fProjectableIdZipPlaceHolders$fProjectableMaybeProjection$fProjectableMaybePlaceHolders$fProjectableShowSqlProjection$fOperatorProjectableProjection $fOperatorProjectableProjection0$fSqlProjectableProjection$fSqlProjectableProjection0$fSqlProjectableProjection1MonadPartition partitionByMonadAggregategroupBygroupBy' MonadQualify liftQualify MonadQuerysetDuplication restrictJoinquery' queryMaybe' MonadRestrictrestrictall'distinctonwhereshaving$fMonadQualifyqqPartitioningSetAggregatingSetListAggregatingPowerSetAggregatingSetPartitioningSetTAggregatingPowerSetTAggregatingSetListTAggregatingSetT Aggregatings aggregatingsextractAggregateTermskeykey'setbkeyrollupcube groupingSets$fMonadPartitioncAggregatings$fMonadAggregateAggregatings$fMonadQueryAggregatings$fMonadQualifyqAggregatings$fMonadRestrictcAggregatings$fMonadTransAggregatings$fMonadAggregatings$fFunctorAggregatings$fApplicativeAggregatings AssignTarget Assignings assigningsassignTo<-#extractAssignments$fMonadQualifyqAssignings$fMonadRestrictcAssignings$fMonadTransAssignings$fMonadAssignings$fFunctorAssignings$fApplicativeAssigningsRegisterextract Orderings orderingsorderByascdescextractOrderingTerms$fProjectableOrderingProjection$fMonadPartitioncOrderings$fMonadAggregateOrderings$fMonadQueryOrderings$fMonadQualifyqOrderings$fMonadRestrictrcOrderings$fMonadTransOrderings$fMonadOrderings$fFunctorOrderings$fApplicativeOrderings Restrictings restrictingsextractRestrict$fMonadAggregateRestrictings$fMonadQueryRestrictings$fMonadQualifyqRestrictings$fMonadRestrictcRestrictings$fMonadTransRestrictings$fMonadRestrictings$fFunctorRestrictings$fApplicativeRestrictingsRestrictAssign InsertTarget UpdateTarget Restriction restriction restriction'sqlWhereFromRestriction updateTarget updateTarget'liftTargetAllColumnliftTargetAllColumn'updateTargetAllColumnupdateTargetAllColumn'sqlFromUpdateTarget insertTarget insertTarget' piRegistersqlChunkFromInsertTargetsqlFromInsertTarget$fShowUpdateTarget$fShowRestriction QueryJoinjoin'unsafeSubQueryWithAttrextractProduct$fMonadQueryQueryJoin$fMonadQualifyqQueryJoin$fMonadTransQueryJoin$fMonadQueryJoin$fFunctorQueryJoin$fApplicativeQueryJoin OrderedQuery QueryCore extractCoreWindowAggregatedQueryQueryAggregate toSubQueryover$fMonadRestrictFlatRestrictings SimpleQuery QuerySimplesimple QueryUniqueunsafeUniqueSubQuery$fMonadQualifyQueryUnique$fMonadQueryQueryUnique$fMonadQueryUnique$fApplicativeQueryUnique$fFunctorQueryUniqueProjectableRunIdsZiprunIdsProjectableFlattenMaybeflattenunsafeAggregateOpcountsumMaybesum'avgMaybeavgmaxMaybemax'minMaybemin'everyany'some'!?!?!?flattenPiMaybe!?? flattenPh$fProjectableRunIdsZipaa$fProjectableRunIdsZip(,)b$fProjectableRunIdsZip(,)b0#$fProjectableFlattenMaybeMaybeMaybe$fProjectableFlattenMaybeMaybeb$fAggregatedContextOverWindow$fAggregatedContextAggregatedUniqueRelationJoinRestrictionderivedRelationtableOfquery 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'relationalQueryunsafeTypedKeyUpdatetypedKeyUpdatetypedKeyUpdateTablederivedKeyUpdateunsafeTypedUpdate updateSQL typedUpdate' typedUpdatederivedUpdate' derivedUpdatetypedUpdateAllColumnderivedUpdateAllColumn'derivedUpdateAllColumnrestrictedUpdateAllColumnrestrictedUpdateTableAllColumnuntypeChunkInsertchunkSizeOfInsertunsafeTypedInsert'unsafeTypedInsert typedInsert' typedInsert derivedInserttypedInsertValue'typedInsertValuederivedInsertValue'derivedInsertValueunsafeTypedInsertQueryinsertQuerySQLtypedInsertQuery'typedInsertQueryderivedInsertQueryunsafeTypedDelete deleteSQL typedDelete' typedDeletederivedDelete' derivedDelete$fUntypeableNoFetchDelete$fUntypeableNoFetchUpdate$fUntypeableNoFetchInsertQuery$fUntypeableNoFetchInsert $fShowDelete$fShowInsertQuery $fShowInsert $fShowUpdate$fShowKeyUpdate $fShowQuery specifiedKeyuniqueprimary'primaryupdateValuesWithKeyupdateByConstraintKey primaryUpdatederivedUniqueRelationQueryA queryExists queryExists' queryListU queryListU' queryScalarU queryScalarU'assign$fCategoryQueryA $fArrowQueryAdefineHasPrimaryKeyInstance%defineHasPrimaryKeyInstanceWithConfigdefineHasNotNullKeyInstance%defineHasNotNullKeyInstanceWithConfig defineColumnsdefineColumnsDefaultdefineTableTypesderivationExpDefaulttableVarExpDefaultrelationVarExpdefineTableTypesWithConfigdefineTableTypesAndRecorddefinePrimaryQuerydefinePrimaryUpdatedefineSqlsWithPrimaryKeydefineSqlsWithPrimaryKeyDefault defineTableunsafeInlineQuery reifyRelation inlineQuerymakeRelationalRecordDefault stringSQLbaseGHC.BaseString showStringSQL rowStringSQLrowPlaceHolderStringSQLrowConsStringSQL listStringSQLUntypedname' columnArraycolumns'<*>fmapGShowConstantTermsSQLgShowConstantTermsSQLPi'unsafeCastRecordWidthmap definePi'Database.Record.PersistablePersistableRecordWidthLeftestMapunsafePiAppend'unsafePiAppend unsafeCastsnd'' intTermsSQLescapeStringToSqlExpr stringExprSQL time-1.6.0.1Data.Time.Clock.UTCUTCTimeData.Time.LocalTime.LocalTime ZonedTime LocalTimeData.Time.LocalTime.TimeOfDay TimeOfDayData.Time.Calendar.DaysDayghc-prim GHC.TypesDoubleFloatBoolChar#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqhData.Text.Internal.LazyTextData.Text.Internalbytestring-0.10.8.1Data.ByteString.Lazy.Internal ByteStringData.ByteString.InternalIntGHC.IntInt64Int32Int16Int8stringTermsSQL floatTermsconstantTimeTermsshowMaybeTerms AggregateElem AggregateSetAggregateBitKeyAggregateColumnRefaggregateColumnRefaggregatePowerKeyaggregateGroupingSetaggregateRollup aggregateCube aggregateSetsaggregateEmptycomposeGroupBycomposePartitionByaggregateKeyProjectionaggregateKeyElementunsafeAggregateKey ColumnRefRollupCube GroupingSetscommaedpCommashowsAggregateBitKey$fShowNameConfigtransformers-0.5.2.0Control.Monad.Trans.ReaderReaderT Assignment AssignTerm AssignColumn OrderingTerm OrderColumn DuplicationshowsDuplicationcomposeOrderBy composeSetscomposeChunkValuescomposeChunkValuesWithColumnsAllDistinctuntypeProjection RawColumn SubQueryRefScalarCase CaseClause WhenClausesProductTreeBuilderQueryProductTreeNode ProductTreeBinOpSetOp qualifier unQualifyqualifynodeAttrnodeTreeuntypedProjectionWidthtypedProjectionprojectionWidthprojectFromColumnsprojectFromScalarSubQuery CaseSearch CaseSimpleLeafJoinQueryRestrictionBuilderQSBinUnionExcept Intersect whenClauses growRight growProductrestrictProduct'restrictProduct JoinContextprimeJoinContext updateProduct joinProductproductQualifyevalQualifyPrimenewAliasfromTableToSQLfromTableToNormalizedSQL normalizedSQLtoSQLs showQualifier columnFromIdqualifiedSQLasindexWhensClause caseClausecolumnOfProjectionUnitcolumnOfUntypedProjectionshowsQueryProductshowsJoinProductcomposeRestrict showsSetOp' showsSetOpsetBinselectPrefixSQL showUnitSQLcolumnN asColumnNunsafeCastPlaceHolder unsafeProjectListSubnotNullMaybeConstraintinsertChunkSQL KeyConstraintunsafeReturnKey mapConstrainttupleNtuplePi compareBinOp monoBinOp monoBinOp'unsafeCastPlaceHoldersOperatorProjectableunsafeFlatUniOp unsafeLikeunsafeCastProjectableunsafeUniTermFunctionunsafeAggregateWithTerm aggregateKeyextractTermList finalizePowertargetProjectionProjectableOrderingupdateOrderBys orderTermsupdateRestrictionrunRestriction_runUpdateTargetupdateAllColumnsqlChunkFromInsertTarget'Control.Monad.Trans.State.LazyStateT updateContextupdateJoinRestriction queryWithAttr extractWindowAggregatedContextjoin_uniqueQueryWithAttrplaceHoldersFromRelation queryList0 addUnitPHunsafeLiftAppend liftAppend liftAppend'typedUpdateAllColumn' targetTablerestrictedTablequeryA runQueryArunAofMunsafeQueryListunsafeQueryList'unsafeQueryScalarunsafeQueryScalar'defineHasConstraintKeyInstancecolumnTemplate'columnTemplatedefineTableDerivableInstancedefineTableDerivations*defineProductConstructorInstanceWithConfigdefineWithPrimaryKeydefineWithNotNullKeyWithConfigtableSQLquotederivationVarNameDefaulttableVarNameDefault