kp      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR 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 { | } ~        !"#$%&'()*+,-./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&{&|&}&~&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((())))))))                         !"#$%&'()**+*,*-*.*/*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*<+2017-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneJXConfiguration type.BNo FROM clause (corresponding the unit of JOIN) is allowed or not. JThreshold count of placeholders in the insert statement with multi-values.  configuration IIf True, schema names become uppercase, and table names become lowercase. ?If True, print warning messages in macros of relational-record. QIf True, more detailed logs are printed when generating record types from schema.If True, instance of ," for each column is NOT generated. If True, -" for each column is NOT generated. configuration configuration2Configuration for quotation of identifiers of SQL.'Schema name qualify mode in SQL string.)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.XConfigurations related to the names of generated record types and their field labels.Function to build the name of .i representing the table. The first argument is the scheme name, and second argument is the table name.Default implementation of  type. Default configuration of O. To change some behaviour of relational-query, use record update syntax: 7 defaultConfig { productUnitSupport = S , chunksInsertSize = 256 , schemaNameMode =  , normalizedTableName = True , verboseAsCompilerWarning = False , disableOverloadedProjection = False , disableSpecializedProjection = False , identifierQuotation = ] , nameConfig = defaultNameConfig { recordConfig = p/ , relationVarName = \schema table -> qu $ table ++ "_" ++ scheme -- ^ append the table name after the schema name. e.g. "schemaTable" } }    r 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneLg    $   /2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeR!#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!"#$%&'2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafeS!"#$%&''&%$#"!02014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe;=Xu(!String wrap type for SQL strings.s( from t.u( to t.vRow String of SQL values.wPlace holder row String of SQL.xList String of SQL.yList String of SQL.zSQL expressions for Bool type.(suvwxyz12013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe]8{Untyped typed table type|Name string of table in SQL}Width of table~Column name strings in SQLColumn name strings in SQL,Column name string in SQL specified by index Column indexColumn name String in SQL{|}{2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneK`). type to require query generate configuration.*Run ) to expand with configuration+Lift to ).,Read configuration.)*+,)+*,)2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone<>?CVv00Projection 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.1!Unsafely expand indexes from key.28Unsafely expand indexes from key. Infered width version.MUnsafely cast width proof object of record. Result record must be same width.0' with zero width which projects to unit3Get record width proof object.4Get record width.5Compose projection path.6Compose projection path.  phantom functor is -ed.7Compose projection path.  phantom functors are join -ed like >=>.8$Unsafely project untyped value list.*Unsafely define projection path from type r0 into type r1.9*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 06 which has record result type using applicative style.?Map projection path 0 which has record result type.Index of flat SQL value listResult projection path9Index of flat SQL value listResult projection path:Indexes of flat SQL value listResult projection path;Indexes of flat SQL value listResult projection path 0123456789:; 03456789:;1205868782013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonexAIdentity projection path.0567A0567A2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>? B Constraint D inference interface.CInfer constraint key.D-Constraint Key proof object. Constraint type c, record type r and columns type ct.E,Index of key which specifies constraint key. Width of key.FUnsafely generate constraint D( proof object using specified key index.GGet table constraint  proof object from constraint D.H1Get projection path proof object from constraint D.6Unsafe. Make constraint key to add column phantom type*Map from table constraint into constraint D.IDerive  constraint D from  constraint DJ Inferred  constraint D. Record type r has unique key which type is ct derived from primay key.F-Key indexes which specify this constraint key"Result constraint key proof object BCDEFGHIJ DEFGHIBCJBCD2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe7<STuKK 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 K, class, so you can make instance like below:  {-# LANGUAGE DeriveGeneric #-} import GHC.Generics (Generic) -- data Foo = Foo { ... } deriving Generic instance ShowConstantTermsSQL Foo M.Convert from haskell record to SQL terms list.(KLMKLLM(KLL22017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone+;=)Make template of K instance of tuple type.&Make polymorphic projection templates.R3Make templates of projection paths for tuple types.R 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=Constant integral SQL terms.Escape t$ for constant SQL string expression.From t% into constant SQL string expression.SConstant SQL terms of # type. Width inference is required.TConstant SQL terms of T. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal with UTC timezone.UConstant SQL terms of B. This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal.VConstant SQL terms of .WConstant SQL terms of .XConstant SQL terms of .YConstant SQL terms of (. Caution for floating-point error rate.ZConstant SQL terms of (. Caution for floating-point error rate.[Constant SQL terms of .\Constant SQL terms of .]Constant SQL terms of .^Constant SQL terms of ._Constant SQL terms of .`Constant SQL terms of .aConstant SQL terms of t.bConstant SQL terms of U. Use this carefully, because this is architecture dependent size of integer type.cConstant SQL terms of .dConstant SQL terms of .eConstant SQL terms of .fConstant SQL terms of .gConstant SQL terms of '()'. 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=4h*Constraint which represents scalar degree.ih instance templates.hihi32015-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone345h)kType for projection function.l/Type for predicate to restrict of query result.m9Phantom typed record. Projected into Haskell record type t.nDiscard record type o,Untyped projected tuple. Forgot record type.p8Projected column structure unit with single column widthq,used in immediate value or unsafe operationsr normalized sub-query reference T n with Int indexsscalar sub-queryt nth column of case clauseu case clausex when clauseszType for join product of query.{.Product node. node attribute and product tree.}KProduct tree type. Product tree is constructed by left node and right node.node attribute for product.Qualified query.Qualifier type.Sub-query typeTypeful aggregate element.Type for group-by treeType for grouping setType for group key.Type for group-by termType for order-by termType for order-by columnOrder of null.)Order direction. Ascendant or Descendant.Set binary operators Set operators#Result record duplication attribute Get qualifier Unqualify. Add qualifierGet node attribute.Get tree from node. Width of o.Unsafely type o value to m type. Width of m.Unsafely generate m from SQL string list.Unsafely generate m from scalar sub-query.!SQL string list specifies columnsResult mHklmnopsqrtuvwxyz{|}~mnpqrstuvwxy{|}~42013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonenUnsafely generate flat  from untyped components.Unsafely generate aggregated  from untyped components.Union binary operator on Except binary operator on Intersect binary operator on .Search case operator correnponding SQL search CASE . Like, 1CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END.Simple case operator correnponding SQL simple CASE . Like, 1CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END*Compose ORDER BY clause from OrderingTerms Error tagEach when clausesElse result record Result clauseEach when clausesElse result record Result recordRecord value to matchEach when clausesElse result record Result record52013-2017 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 node62013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone]  Single term aggregation element.Key of aggregation power set.Single grouping set.Rollup aggregation element.Cube aggregation element.Grouping sets aggregation.0Compose GROUP BY clause from AggregateElem list.9Compose PARTITION BY clause from AggregateColumnRef list.Extract typed record from .Extract untyped term from .1Unsafely bind typed-record and untyped-term into . 72013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNones%Compose duplication attribute string.Alias string from qualifierBinary operator to qualify.9Qualified expression from qualifier and projection index.From " SQL string into qualified formed t like (SELECT ...) AS T n Width of . Width of  SubQUery.&Generate SQL from table for top-level.*Generate normalized column SQL from table.1Generate normalized column SQL from joined tuple.Normalized column SQL for union like operations to keep compatibility with engines like Sqlite and MySQL. SQL with no ordering term is not paren-ed.-SQL string for nested-query and toplevel-SQL.SQL string for nested-qeury.SQL StringSQL for toplevel-SQL.SQL string for toplevel-SQL.Get column SQL string of  .BMake untyped tuple (qualified column list) from joined sub-query ( ).1index result of each when clause and else clause.1index result of each when clause and else clause.:Convert from typed' Column' into column string expression.Get column SQL string of o.%Get column SQL string list of record.6Show product tree of query into SQL. StringSQL result.Shows join product of query.Compose SQL String from QueryRestriction.Compose WHERE clause from QueryRestriction.Compose HAVING clause from QueryRestriction.sub-query SQL and top-level SQLSource o Column indexResult SQL stringSource mResult SQL string list 82013-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownSafe Assignment pairValue SQL String of assignmentColumn SQL String of assignmentCompose SET clause from [].6Compose VALUES clause from a row of value expressions.FCompose columns row and VALUES clause from a row of value expressions.JCompose columns row and VALUES clause from rows list of value expressions.record count per chunkvalue expression listrecord count per chunk 2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonePnklmnopsqrtuvwxyz{|}~o}~{|zuvwxypqrstomnnkl 2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneBPlaceholder parameter type which has real parameter type arguemnt p.9Constraint to restrict context of aggregated SQL context.Constraint to restrict context of full SQL expressions. For example, the expression at the left of OVER clause is not allowed using full SQL expression.(Interface to project SQL terms unsafely.+Unsafely project from SQL expression terms.92013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneK &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-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone SJoinContext type for QueryJoin.Initial .Update product of .6Finalize context to extract accumulated query product.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. of  type.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 W Inference rule of  existence.Phantom typed table type Untype table.Deprecated. use .Name string of table in SQL)Not qualified name string of table in SQLWidth of tableColumn name strings in SQL,Column name string in SQL specified by indexCast phantom type into  type.+Unsafely generate phantom typed table type. from .PersistableRecordWidth of table Column indexColumn name String in SQLTyped  metadataResult 2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone<>?7(Projected record list type for row list.Unsafely get SQL term from m.%Get column SQL string list of record. Width of m.Get untyped tuple.Unsafely generate m# from qualified (joined) sub-query.Unsafely generate m from scalar sub-query.Unsafely generate unqualified m from .Unsafely generate m from SQL expression strings.Unsafely trace projection path.&Trace projection path to get narrower m.&Trace projection path to get narrower m.&Trace projection path to get narrower m. From  type to  type.&Trace projection path to get narrower m. From  type to * type. Leaf type of projection path is .Composite nested  on record phantom type.  Cast into  on record 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 record. Make projected record list from m list. Make projected record list from .EMap record show operatoions and concatinate to single SQL expression.Compose m using applicative style.Map m which result type is record.Source mResult SQL string listSource mProjection path Narrower mSource m Record path Narrower mSource m.  typeProjection path Narrower m.  type resultSource m.  typeProjection path.  type leaf Narrower m.  type resultm     m     2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneER 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.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 SQLTable metadata Result SQL2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone>?M Compose record type  using applicative style.Compose seed of record type .LZipping except for identity element laws against placeholder parameter type.$ context is aggregated context& context is aggregated context5full SQL expression is availabe in Aggregated context /full SQL expression is availabe in Flat context!Unsafely make Record from SQL terms."Unsafely make Record from SQL terms.#Unsafely make Record from SQL terms.2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=VP7?!Projection path for fst of tuple.@!Projection path for snd of tuple.$%&'()*+,-./0123456789:;<=>?@#>=<;:9876543210/.-,+*)('&%$AAAAAA?@2013-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>?bGInterface to compose phantom  nested type.IInterface to control  of phantom type in records.JCast record phantom type into .KCompose nested  phantom type on record.L$Binary operator type for SQL String.M!Unsafely Project single SQL term.N8Unsafely Project single SQL string. String interface of unsafeProjectSql''.OYRecord with polymorphic phantom type of SQL null value. Semantics of comparing is unsafe.PPGenerate record with polymorphic type of SQL constant values from Haskell value.Q/Record with polymorphic type of SQL true value.R0Record with polymorphic type of SQL false value.SDRecordList with polymorphic type of SQL set value from Haskell list.T9Unsafely generate SQL expression term from record object.USUnsafely generate SQL expression string from record object. String interface of T.V:Unsafely make unary operator for records from SQL keyword.WFUnsafely make binary operator for records from string binary operator.MUnsafely make binary operator to compare records from string binary operator.OUnsafely make numrical binary operator for records from string binary operator.X#Compare operator corresponding SQL = .Y#Compare operator corresponding SQL < .Z#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 .a#Logical operator corresponding SQL EXISTS .b'Concatinate operator corresponding SQL || .c'Concatinate operator corresponding SQL || . Maybe type version.d*String-compare operator corresponding SQL LIKE .e*String-compare operator corresponding SQL LIKE .f*String-compare operator corresponding SQL LIKE .g*String-compare operator corresponding SQL LIKE . Maybe type version.JUnsafely make number binary operator for records from SQL operator string.h"Number operator corresponding SQL + .i"Number operator corresponding SQL - .j'Number operator corresponding SQL /// .k"Number operator corresponding SQL * .l-Number negate uni-operator corresponding SQL -.m!Number fromIntegral uni-operator.n6Unsafely show number into string-like type in records.o"Number operator corresponding SQL + .p"Number operator corresponding SQL - .q'Number operator corresponding SQL /// .r"Number operator corresponding SQL * .s-Number negate uni-operator corresponding SQL -.t!Number fromIntegral uni-operator.u6Unsafely show number into string-like type in records.v.Search case operator correnponding SQL search CASE . Like, 1CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c ENDwSame as v, but you can write like  whenlist w  elseclause.xNull default version of v.y.Simple case operator correnponding SQL simple CASE . Like, 1CASE x WHEN v THEN a WHEN w THEN b ... ELSE c ENDzUncurry version of y, and you can write like ... z  elseclause.{Null default version of y.|"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"No placeholder semantics. Same as )Unsafely cast placeholder parameter type.FProvide 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 .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./Get narrower record along with projection path.2Get narrower record along with projection path  phantom functor is -ed.hGet narrower record along with projection path and project into result record type. Source record * phantom functor and projection path leaf  functor are join-ed.UGet narrower record with flatten leaf phantom Maybe types along with projection path.UGet narrower record with flatten leaf phantom Maybe types along with projection path.7Same as '(?!)'. Use this operator like '(? #foo) mayX'.9Same as '(?!?)'. Use this operator like '(?? #foo) mayX'.Control phantom  type in record type m.Control phantom  type in placeholder parameters.Not  type is not processed.Compose  type in record phantom type.USource record objectResult SQL expression string.vEach when clausesElse result record Result recordwEach when clausesElse result record Result recordxEach when clauses Result recordyRecord value to matchEach when clausesElse result record Result recordz0Record value to match and each when clauses listElse result record Result record{Record value to matchEach when clauses Result recordSource m Record pathNarrower projected objectSource m.  type Record pathNarrower projected object.  type resultSource m.  phantom type Record path.  type leafNarrower projected object.  phantom type resultSource m.  phantom typeProjection path Narrower m . Flatten  phantom typeSource m.  phantom typeProjection path&Narrower flatten and projected object.Source m.  type Record pathNarrower projected object.  type resultSource m.  phantom type Record path.  type leafNarrower projected object.  phantom type result^GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~^MNPQRSOTUXYZ[\]^_|bcfgdehikjoprq}~`almnstuwzvxy{LWVIJKGHGHIJKX4Y4Z4[4\4]4^3_2b5c5d4e4f4g4h6i6j7k7o6p6q7r7|418888882017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone -;<=>?AFV;Projection interface to implement Pi with row polymorphism.Derive k label.Derive  instance from .;2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone0Projection template for monomorphic record type.8Projection templates for record type with type variable.$Projection templates for tuple type.2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone -;=>?VD2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>?>(Window specification building interface.Add  PARTITION BY term into context.,Aggregated query building interface extends .Add GROUP BY- term into context and get aggregated record.'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 .+Join sub-query with place-holder parameter p. Query result is .Restrict context interface Add restriction to this context.'Specify ALL attribute to query context.,Specify DISTINCT attribute to query context.2Add restriction to last join. Record type version.-Add restriction to this not aggregated query.IAdd restriction to this aggregated query. Aggregated Record type version.Record to add into group by,Result context and aggregated record | Add GROUP BYO term into context and get aggregated record. Non-traditional group-by version.7Key to aggretate for non-traditional group-by interface$Result context and aggregated recordm which represent restrictionRestricted query contextm which represent restrictionRestricted query context2014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?K#/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 QueryRestriction Resticted  instance. Restricted  instance. Restricted  instance. instance.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?1RestrictedStatement type synonym. 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 QueryRestriction.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>?K -Type to accumulate ordering context. Type c& is ordering term record context type.Lift to .Add ordering terms.&Add ordering terms with null ordering.Add ordering terms.Add ascendant ordering term.Add descendant ordering term.Run  to get  OrderingTerms with ordering. with ordering. with ordering. with ordering. with ordering.Order directionOrdering terms to addResult context with orderingOrdering terms to addOrder direction Order of nullResult context with orderingOrdering terms to addOrder directionResult context with orderingOrdering terms to addResult context with orderingOrdering terms to addResult context with ordering2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>?K) 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 zJoinable query instance.Attribute maybe or just to join$Result joined context and record of  result.2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone.OrderedQuery monad type with placeholder type p. Record must be the same as  context type parameter c.PCore query monad type used from flat(not-aggregated) query and aggregated query.Extract  computation.2014-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?KDUnique query monad type./Unsafely join sub-query with this unique query.Run  SimpleQuery to get  with Qualify computation.Attribute maybe or just to join$Result joined context and record of  result. to runResult  with Qualify computation2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?$Simple (not-aggregated) query type.  SimpleQuery' p r ==  ( p, m 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. to runResult SQL string with Qualify computation SimpleQuery' to runResult  with Qualify computation2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?K Target of assignment..Type to accumulate assigning context. Type r is table record type.Lift to Add an assignment.Add and assginment.Run  to get  Assignments with assigning. with assigning.4 2015-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone x6Target register monad type used from insert statement. Run InsertStatement.  !2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;=>?!AssignStatement type synonym. Specifying assignments and restrictions like update statement. 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;=>?K#X$/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.()Context type building partition keys set.)&Context type building power group set.*)Context type building grouping sets list.+'Context type building one grouping set.,0Type 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.-Lift to ,..Run , to get terms list.//Specify key of single grouping set from Record.0#Specify key of single grouping set.1)Finalize and specify single grouping set.2)Specify key of rollup and cube power set.30Finalize grouping power set as rollup power set.4.Finalize grouping power set as cube power set.5Finalize grouping set list.6Aggregated query instance.7 Aggregated .8 Aggregated .9 Aggregated .:Partition clause instance$%&'()*+,-./012345,-+*)(.'&%$/012345,#2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;<=>?+?-Partition monad type for partition-by clause.@Aggregated query type. @ p r == A ( p, m & r).AAggregated query monad type.BRun @ to get SQL with  computation.CRun @ to get  with  computation.D>Operator to make record of window function result using built ? monad.E Restricted  instance.B@ to runResult SQL string with  computationC@ to runResult  with  computation?@ABCDA@BC?DD8$2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone<?F/Unique relation type to compose scalar queries.GSimple  from .H Inferred .IInterface to derive  type object.J$Join sub-query. Query result is not .K Join sub-query. Query result is . The combinations of J and K 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 LList sub-query, for IN and EXIST with place-holder parameter p.MList sub-query, for IN and EXIST.N Finalize  monad and generate  with place-holder parameter p.O Finalize  monad and generate .P Finalize A monad and geneate  with place-holder parameter p.Q Finalize A monad and geneate .R!Unsafely specify unique relation.SDiscard unique attribute.#Basic monadic join operation using .T2Join unique sub-query with place-holder parameter p.U2Join unique sub-query with place-holder parameter p. Query result is .V Finalize  monad and generate F.W Aggregated F.X-Scalar sub-query with place-holder parameter p.YScalar sub-query.FGHIJKLMNOPQRSTUVWXYGHIONQPFRSVWJKMLYXTUF%2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonea&ZzRestriction predicate function type for direct style join operator, used on predicates of direct join style as follows. # do xy <- query $ relX _ relY cF [ x y -> ... ] -- this lambda form has JoinRestriction type ... 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.aDirect right outer join.bDirect full outer join.c(Apply restriction for direct join style.dUnion of two relations.e%Union of two relations. Not distinct.fSubtraction of two relations.g+Subtraction of two relations. Not distinct.hIntersection of two relations.i,Intersection of two relations. Not distinct.j4Union of two relations with place-holder parameters.kBUnion of two relations with place-holder parameters. Not distinct.l:Subtraction of two relations with place-holder parameters.mHSubtraction of two relations with place-holder parameters. Not distinct.n;Intersection of two relations with place-holder parameters.oIIntersection of two relations with place-holder parameters. Not distinct.[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 relation`Left query to joinRight query to joinJoin restrictionsResult joined relationaLeft query to joinRight query to joinJoin restrictionsResult joined relationbLeft query to joinRight query to joinJoin restrictionsResult joined relationZ[\]^_`abcdefghijklmnoZ[\]^_`abcdfhegijlnkmo[8\8]8^8_8`8a8b8c8d7e7f7g7h8i8j7k7l7m7n8o8&2013-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNonewAp.InsertTarget type with place-holder parameter p and projected record type r.q.UpdateTarget type with place-holder parameter p and projected record type r.r-Restriction type with place-holder parameter p and projected record type r.s Finalize Restrict monad and generate r.t Finalize Restrict monad and generate r with place-holder parameter puSQL WHERE clause ( 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 ( string from q} Finalize  monad and generate p.~ Finalize Target monad and generate q with place-holder parameter p.parametalized  monad from 0Make (2 string of SQL INSERT record chunk statement from pMake (% string of SQL INSERT statement from pMake (0 strings of SQL INSERT strings from records listShow where clause.pqrstuvwxyz{|}~rstqvwxyz{p}~u|pqr'2013-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneQFzUntype 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  and key columns selector 0. Make typed ( object using derived info specified by  type. Make typed - from derived table and key columns selector 0. Make typed - from derived table and key columns selector 0.Unsafely make typed  from SQL string.$Make untyped update SQL string from  and q. Make typed  from ,  and q. Make typed  using  ,  and q. Make typed  from , derived table and ! Make typed  from , derived table and ! Make typed  from  , derived table and ! Make typed  from  , derived table and ! with no(unit) placeholder. Make typed  from  , derived table and ! Make typed  from ,  and r!. Update target is all column. Make typed  from  and r!. Update target is all column. Make typed  from , derived table and !!. Update target is all column. Make typed  from , derived table and !!. Update target is all column. Make typed  from  , derived table and !!. Update target is all column. Make typed  from  , derived table and !X without placeholder other than target table columns. Update target is all column. Make typed  from  , derived table and !!. 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  and columns selector 0 with configuration parameter. Make typed  from  and columns selector 0.Table type inferred .Table type inferred . Make typed  from ,  and monadic builded p object. Make typed  from  and monadic builded p object. Make typed  from $, derived table and monadic builded  object. Make typed  from $, derived table and monadic builded  object. Make typed  from  $, derived table and monadic builded  object. Make typed  from  $, derived table and monadic builded " object with no(unit) placeholder. Make typed  from  $, derived table and monadic builded  object. Make typed  list from  and records list. Make typed  list from records list.Unsafely make typed  from SQL string.+Make untyped insert select SQL string from , 0 and . Make typed  from columns selector , 0 and  with configuration parameter. Make typed  from columns selector , 0 and .Table type inferred .Table type inferred .Unsafely make typed  from SQL string.$Make untyped delete SQL string from  and r. Make typed  from ,  and r. Make typed  from  and r. Make typed  from , derived table and RestrictContext Make typed  from , derived table and RestrictContext Make typed  from  , derived table and RestrictContext Make typed  from  , derived table and RestrictContext with no(unit) placeholder. Make typed  from  , derived table and RestrictContextShow query SQL stringShow update SQL stringShow update SQL stringShow insert SQL string.Show insert SQL string.Show delete SQL stringQuery SQL to type Typed resultNN(2017-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone7<>?A%Sequence number type for record type r$Derivation rule for binding between  and BRecord to express binding between normal-table and sequence-table.$normal-table bound to sequence-table(sequence key projection for bound recordsequence table record derivation ruleyBasic record to express sequence-table. actual sequence-table is a table which has only one column of integer type.actual sequence-table,sequence number selector for sequence record.sequence number projection for sequence record Unsafely specify sequence table.Infer  of sequence tableAUnsafely specify binding between normal-table and sequence-table.!Derive binding using primary key.Derive  from corresponding !Unsafely specify sequence number.Get untyped sequence number.Unsafely apply sequence number.MUnsafely apply sequence number. Only safe to build corresponding record type.#Update statement for sequence table#Update statement for sequence table:sequence number should be passed to proper field of record:sequence number should be passed to proper field of record2sequence number to set. expect not SQL injectable.sequence table2sequence number to set. expect not SQL injectable.sequence table)2013-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone<$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.F 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  to updateKey with constraint c, record type r and columns type p Result typed Update 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-2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone    !"#$%&'(0567ABCDGHIJKLMhklm$%&'()*+,-./0123456789:;<=>?@GHIKJLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"/012345?@ADFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 2013-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone ;=>?HV9I&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.Projection path 0 templates.Overloaded projection path 0 templates.9Make projection path templates using default naming rule.DMake overloaded projection path 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 & 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 .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  in compile type.8Extract param type and result type from defined RelationInlining composed  in compile type.nGenerate all templates against defined record like type constructor other than depending on sql-value type.nGenerate all templates against defined record like type constructor other than depending on sql-value type.Constraint type Record typeKey typeIndexes specifies keyResult B 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 keyRecord type name Column declaration variable nameColumn leftest index Column type"Column projection path declarationRecord type nameColumn info list#Column projection path declarationsRecord type nameColumn info list#Column projection path declarationsRecord 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 declaration Table name stringResult var Exp Table name stringResult var Exp 2Configuration 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 Record type of  expressionResult  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 declarationType constructor nameResult declarationRi      iR    =2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone;BRi     2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone+;<=FJr.Interface to get SQL expression from a record.(Interface to project SQL terms unsafely.+Unsafely project from SQL expression terms. deprecated  class replaced by  class. deprecated  class replaced by  class. deprecated  class replaced by  class. deprecated   type replaced by m type.  deprecated   type replaced by m type.!/deprecated right-id-law definition replaced by ".deprecated left-id-law definition replaced by #,deprecated map definition for Pi type. use () instead of this.$+deprecated ap definition for Pi type. use () instead of this.%-deprecated empty definition for Pi type. use  instead of this.&EDeprecated. Use Database.Relational.unsafeProjectSql instead of this.'BDeprecated. Use Database.Relational.unsafeShowSql instead of this.(Unsafely make m from SQL terms.SQL expression strings Result record !"#$%&' !"&'#$%>2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNoneLM    !"#$%&'(0567ABCDGHIJKLMhklm$%&'()*+,-./0123456789:;<=>?@GHIKJLMOPQRSVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"/012345?@ADFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'*2015-2018 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone<K@D*Arrow type corresponding to ?@+Arrow type corresponding to ,Arrow type corresponding to ?A-Arrow type corresponding to .Arrow type corresponding to ?/Arrow type corresponding to 0Arrow type corresponding to &1Arrow type corresponding to %2Arrow type corresponding to '3Arrow type corresponding to 4Arrow type corresponding to A5Arrow type corresponding to 6Arrow to build queries.7Same as . Arrow version.8Same as . Arrow version.9Same as JP. Arrow version. The result arrow is not injected by local projected records.:Same as KT. Arrow version. The result arrow is not injected by any local projected records.;Same as T. Arrow version. The result arrow is not injected by any local projected records.<Same as T. Arrow version. The result arrow is not injected by any local projected records.=Same as M[. Arrow version. The result arrow is designed to be injected by local projected records.>Same as L[. Arrow version. The result arrow is designed to be injected by local projected records.?Same as M to pass this result to ad operator. Arrow version. The result arrow is designed to be injected by local projected records.@Same as L to pass this result to ad operator. Arrow version. The result arrow is designed to be injected by local projected records.ASame as MM. Arrow version. Useful for no reference cases to local projected records.BSame as LM. Arrow version. Useful for no reference cases to local projected records.CSame as Y^. Arrow version. The result arrow is designed to be injected by any local projected record.DSame as X^. Arrow version. The result arrow is designed to be injected by any local projected record.ESame as YM. Arrow version. Useful for no reference cases to local projected records.FSame as XM. Arrow version. Useful for no reference cases to local projected records.GSame as TP. Arrow version. The result arrow is not injected by local projected records.HSame as UP. Arrow version. The result arrow is not injected by local projected records.ISame as b. Arrow version. The result arrow is designed to be injected by local conditional flat-records.JSame as b. Arrow version. The result arrow is designed to be injected by local conditional flat-records.KSame as h. Arrow version. The result arrow is designed to be injected by local conditional aggregated-records.LSame as V. Arrow version. The result arrow is designed to be injected by local flat-records.MSame as j. Arrow version. The result arrow is designed to be injected by locally built arrow using placeholders.NSame as OC. Finalize query-building arrow instead of query-building monad.OSame as NC. Finalize query-building arrow instead of query-building monad.PSame as QC. Finalize query-building arrow instead of query-building monad.QSame as PC. Finalize query-building arrow instead of query-building monad.RSame as VC. Finalize query-building arrow instead of query-building monad.SSame as 4. This arrow is designed to be injected by local .TSame as /A. This arrow is designed to be injected by local flat-records.USame as 04. This arrow is designed to be injected by local  AggregteKey.VSame as 1<. This arrow is designed to be injected by locally built  AggregtingSet arrow.WSame as 2A. This arrow is designed to be injected by local flat-records.XSame as 3. Finalize locally built 0.YSame as 4. Finalize locally built 0.ZSame as 5. Finalize locally built 1.[Same as L. The result arrow is designed to be injected by local projected records.\Same as L. The result arrow is designed to be injected by local projected records.]Same as L. The result arrow is designed to be injected by local projected records.^Same as L. The result arrow is designed to be injected by local projected records._Same as L. The result arrow is designed to be injected by local projected records.`Same as D7. Make record of window function result using built . arrow.aMake W into arrow which is designed to be injected by assignees of local projected record.bSame as  . Make 4 from assigning statement arrow using configuration.cSame as  . Make  from assigning statement arrow.dSame as  . Make ) from register arrow using configuration.eSame as  . Make  from register arrow.fSame as  . Make 3 from restrict statement arrow using configuration.gSame as  . Make  from restrict statement arrow.hSame as  . Make 4 from assigning statement arrow using configuration.iSame as  . Make  from assigning statement arrow.jSame as  . Make ) from register arrow using configuration.kSame as  . Make  from register arrow.lSame as  . Make 3 from restrict statement arrow using configuration.mSame as  . Make  from restrict statement arrow.    !"#$%&'(0567ABCDGHIJKLMhklm$%&'()*+,-./0123456789:;<=>?@GHIKJLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"@FGHIRSWZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmD789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg6543210/.-,+*hijklm6`8B2017 Kei HibinoBSD3ex8k.hibino@gmail.com experimentalunknownNone]    !"#$%&'(0567ABCDGHIJKLMhklm$%&'()*+,-./0123456789:;<=>?@GHIKJLMOPQRSVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"@FGHIRSWZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmCDECDFCDGHIJHIKHLMHLN+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+c+d+e+f+g/h/i/j/k/l/m/n0opqrstuv-wxyz{|}~2  3333333333333333333333333333333n3m33333333333333333333333333333333333333334444444455666666666667z777777 7 7 7 8 888888      . !"#$%&'()*+z,-./012,z(34567~89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{;:|}~,     @ !"#$%&'()*+,-./01230456789:;0<=>?@ABCDEFG H !A!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##0#h#i$j$/$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|%}%~%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((( ( ( ( ( (((())))))))        ! " # $ % & ' ( ) * + , - . / 0 123456789:;<=~>?*@*H*A*=*e**L*K*M*2*g*:*@***m*n***p*o*A*B*C*D*|*{*E*F*w*x******r*q*t*s*y**U*V*W*X*Y*Z*[******h*G*************H*ICJfKLM+O0NOPQ0R0S0T0U0V0W1X1Y1y1Z1[11X\]^p_`=OPOPabCcd-efgzCDhijkl2m2n o p qrstruvrwxryzr{|}~}~}~}~}~OOOO3455777{77777777777777999999::::::O;;;\%2="R$$E%&%&&&'(((       HIHIHIHIHIHI*@/relational-query-0.11.2.0-4Nci65bRAlxetgc7Hz8wvDatabase.Relational.ConstraintDatabase.Relational.CompatDatabase.Relational.ConfigDatabase.Relational.Context$Database.Relational.ProjectableClass&Database.Relational.Monad.Trans.ConfigDatabase.Relational.Pi.UnsafeDatabase.Relational.PiDatabase.Relational.THDatabase.Relational.PureDatabase.Relational.ScalarDatabase.Relational.SqlSyntax&Database.Relational.Projectable.Unsafe"Database.Relational.Monad.BaseTypeDatabase.Relational.TableDatabase.Relational.RecordDatabase.Relational.SimpleSql)Database.Relational.Projectable.Instances"Database.Relational.TupleInstancesDatabase.Relational.Projectable(Database.Relational.OverloadedProjection'Database.Relational.OverloadedInstancesDatabase.Relational.Monad.Class+Database.Relational.Monad.Trans.Restricting"Database.Relational.Monad.Restrict(Database.Relational.Monad.Trans.Ordering$Database.Relational.Monad.Trans.JoinDatabase.Relational.Monad.Type Database.Relational.Monad.Unique Database.Relational.Monad.Simple)Database.Relational.Monad.Trans.Assigning"Database.Relational.Monad.Register Database.Relational.Monad.Assign+Database.Relational.Monad.Trans.Aggregating#Database.Relational.Monad.AggregateDatabase.Relational.RelationDatabase.Relational.SetDatabase.Relational.EffectDatabase.Relational.TypeDatabase.Relational.SequenceDatabase.Relational.DerivesDatabase.Relational.Arrow#Database.Relational.Internal.Config HasProjectionPiRelation(Database.Relational.Internal.ContextType#Database.Relational.Internal.String)Database.Relational.Internal.UntypedTable#Database.Relational.InternalTH.Base#Database.Relational.SqlSyntax.Types#Database.Relational.SqlSyntax.Query"Database.Relational.SqlSyntax.Join'Database.Relational.SqlSyntax.Aggregate"Database.Relational.SqlSyntax.Fold%Database.Relational.SqlSyntax.Updates'Database.Relational.Monad.Trans.Qualify)Database.Relational.Monad.Trans.JoinState)Database.Relational.InternalTH.OverloadedDatabase.RelationalDatabase.Relational.Query.THDatabase.Relational.QueryMonadicRestrictedStatementAssignStatementDatabase.Relational.Query.Arrow1persistable-record-0.6.0.3-BGNqE3AgAwvF2jboFThgpmDatabase.Record.KeyConstraintUniqueNotNullPrimary1product-isomorphic-0.0.3.2-5e3QylIj3FQ298Zo46rqzr$Data.Functor.ProductIsomorphic.Class|$||*|%Data.Functor.ProductIsomorphic.UnsafeproductConstructorProductConstructorConfigproductUnitSupportchunksInsertSizeschemaNameModenormalizedTableName enableWarningverboseAsCompilerWarningdisableOverloadedProjectiondisableSpecializedProjectionidentifierQuotation nameConfigIdentifierQuotation NoQuotation QuotationSchemaNameModeSchemaQualifiedSchemaNotQualifiedProductUnitSupport PUSupportedPUNotSupported NameConfig recordConfigrelationVarNamedefaultNameConfig defaultConfigPowerSetListSet OverWindowExists AggregatedFlat StringSQL QueryConfigrunQueryConfig queryConfigaskQueryConfig$fMonadQueryConfig$fFunctorQueryConfig$fApplicativeQueryConfigunsafeExpandIndexes'unsafeExpandIndexeswidth'width<.>pidefinePidefineDirectPi'defineDirectPi$fCategoryTYPEPi$fProductIsoEmptyPi()$fProductIsoApplicativePi$fProductIsoFunctorPi$fShowPiid'HasConstraintKey constraintKeyKeyindexesunsafeDefineConstraintKeytableConstraint projectionKey uniqueKeyderivedUniqueKeyShowConstantTermsSQLshowConstantTermsSQL'showConstantTermsSQL$fGShowConstantTermsSQLM1$fGShowConstantTermsSQL:*:$fGShowConstantTermsSQLU1$fGShowConstantTermsSQLK1 defineTuplePi$fShowConstantTermsSQLMaybe$fShowConstantTermsSQLUTCTime$fShowConstantTermsSQLZonedTime$fShowConstantTermsSQLLocalTime$fShowConstantTermsSQLTimeOfDay$fShowConstantTermsSQLDay$fShowConstantTermsSQLDouble$fShowConstantTermsSQLFloat$fShowConstantTermsSQLBool$fShowConstantTermsSQLChar$fShowConstantTermsSQLText$fShowConstantTermsSQLText0 $fShowConstantTermsSQLByteString!$fShowConstantTermsSQLByteString0$fShowConstantTermsSQL[]$fShowConstantTermsSQLInt$fShowConstantTermsSQLInt64$fShowConstantTermsSQLInt32$fShowConstantTermsSQLInt16$fShowConstantTermsSQLInt8$fShowConstantTermsSQL() ScalarDegreedefineScalarDegree$fScalarDegreeMaybePI PredicateRecord untypeRecordTupleColumn RawColumn SubQueryRefScalarCase CaseClause CaseSearch CaseSimple WhenClauses JoinProductNode ProductTreeLeafJoinNodeAttrJust'Maybe Qualified QualifierSubQueryTableBin AggregateKey AggregateElem ColumnRefRollupCube GroupingSets AggregateSetAggregateBitKeyAggregateColumnRef OrderingTerm OrderColumnNulls NullsFirst NullsLastOrderAscDescBinOpSetOpUnionExcept Intersect DuplicationAllDistinct qualifier unQualifyqualifynodeAttrnodeTree tupleWidthrecord recordWidthtypeFromRawColumnstypeFromScalarSubQuery flatSubQueryaggregatedSubQueryunionexcept intersect caseSearchcase'composeOrderBy growProductrestrictProductaggregateColumnRefaggregatePowerKeyaggregateGroupingSetaggregateRollup aggregateCube aggregateSetscomposeGroupBycomposePartitionByaggregateKeyRecordaggregateKeyElementunsafeAggregateKey queryWidthunitSQLshowSQLtoSQLcolumntupleFromJoinedSubQueryrecordRawColumns composeWhere composeHaving Assignment AssignTerm AssignColumn composeSetscomposeChunkValuescomposeChunkValuesWithColumnscomposeValuesListWithColumns PlaceHoldersAggregatedContextOperatorContext SqlContextunsafeProjectSqlTermsConfigureQueryconfigureQuery qualifyQuery askConfigunsafeTypeRelationuntypeRelation relationWidthrightPhleftPhsqlFromRelationWithsqlFromRelationdump$fShowRelationTableDerivable derivedTableuntypeunTypename shortNamecolumnsindextoMaybetable toSubQuery RecordListunsafeStringSqlunsafeFromQualifiedSubQueryunsafeFromScalarSubQueryunsafeFromTableunsafeFromSqlTermswpipiMaybepiMaybe' flattenMaybejustunsafeChangeContextunsafeToAggregated unsafeToFlatunsafeStringSqlNotNullMaybelistunsafeListFromSubQueryunsafeStringSqlList$fProductIsoEmptyRecord()$fProductIsoApplicativeRecord$fProductIsoFunctorRecord QuerySuffixshowsQuerySuffixupdatePrefixSQLupdateOtherThanKeySQLinsertPrefixSQLdeletePrefixSQL#$fProductIsoApplicativePlaceHolders$fProductIsoFunctorPlaceHolders$fProductIsoEmptyPlaceHolders()$fAggregatedContextOverWindow$fAggregatedContextAggregated$fOperatorContextAggregated$fOperatorContextFlat$fSqlContextOverWindow$fSqlContextAggregated$fSqlContextFlat 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'fst'snd'$fShowConstantTermsSQL(,,,,,,)$fShowConstantTermsSQL(,,,,,)$fShowConstantTermsSQL(,,,,)$fShowConstantTermsSQL(,,,)$fShowConstantTermsSQL(,,)$fShowConstantTermsSQL(,)ProjectableFlattenMaybeflattenProjectableMaybeSqlBinOpunsafeProjectSql'unsafeProjectSqlnothingvalue valueTrue valueFalsevaluesunsafeShowSql' unsafeShowSql unsafeUniOp unsafeBinOp.=..<..<=..>..>=..<>.and'or'not'exists.||.?||?like' likeMaybe'like likeMaybe.+..-../..*.negate' fromIntegral'showNum?+??-??/??*? negateMaybefromIntegralMaybe showNumMaybe casesOrElsecaseSearchMaybe casesOrElse' caseMaybein' isNothingisJust fromMayberank denseRank rowNumber percentRankcumeDistunsafeAddPlaceHoldersunsafePlaceHoldersunitPlaceHolderunitPH pwPlaceholder placeholder' placeholder projectZip><unsafeAggregateOpcountsumMaybesum'avgMaybeavgmaxMaybemax'minMaybemin'everyany'some'!?!?!?flattenPiMaybe!?????$fProjectableMaybeRecord$fProjectableMaybePlaceHolders#$fProjectableFlattenMaybeMaybeMaybe$fProjectableFlattenMaybeMaybeb projection$fIsLabell(->) $fIsLabellPi$fHasProjection"snd"(,)b$fHasProjection"fst"(,)a%$fHasProjection"tuplePi7_6"(,,,,,,)a7%$fHasProjection"tuplePi7_5"(,,,,,,)a6%$fHasProjection"tuplePi7_4"(,,,,,,)a5%$fHasProjection"tuplePi7_3"(,,,,,,)a4%$fHasProjection"tuplePi7_2"(,,,,,,)a3%$fHasProjection"tuplePi7_1"(,,,,,,)a2%$fHasProjection"tuplePi7_0"(,,,,,,)a1$$fHasProjection"tuplePi6_5"(,,,,,)a6$$fHasProjection"tuplePi6_4"(,,,,,)a5$$fHasProjection"tuplePi6_3"(,,,,,)a4$$fHasProjection"tuplePi6_2"(,,,,,)a3$$fHasProjection"tuplePi6_1"(,,,,,)a2$$fHasProjection"tuplePi6_0"(,,,,,)a1#$fHasProjection"tuplePi5_4"(,,,,)a5#$fHasProjection"tuplePi5_3"(,,,,)a4#$fHasProjection"tuplePi5_2"(,,,,)a3#$fHasProjection"tuplePi5_1"(,,,,)a2#$fHasProjection"tuplePi5_0"(,,,,)a1"$fHasProjection"tuplePi4_3"(,,,)a4"$fHasProjection"tuplePi4_2"(,,,)a3"$fHasProjection"tuplePi4_1"(,,,)a2"$fHasProjection"tuplePi4_0"(,,,)a1!$fHasProjection"tuplePi3_2"(,,)a3!$fHasProjection"tuplePi3_1"(,,)a2!$fHasProjection"tuplePi3_0"(,,)a1 $fHasProjection"tuplePi2_1"(,)a2 $fHasProjection"tuplePi2_0"(,)a1MonadPartition partitionByMonadAggregategroupBygroupBy' MonadQualify liftQualify MonadQuerysetDuplication restrictJoinquery' queryMaybe' MonadRestrictrestrictall'distinctonwhereshaving$fMonadQualifyqq Restrictings restrictingsextractRestrict$fMonadAggregateRestrictings$fMonadQueryRestrictings$fMonadQualifyqRestrictings$fMonadRestrictcRestrictings$fMonadTransRestrictings$fMonadRestrictings$fFunctorRestrictings$fApplicativeRestrictingsRestrictextract Orderings orderingsorderBy'orderByascdescextractOrderingTerms$fMonadPartitioncOrderings$fMonadAggregateOrderings$fMonadQueryOrderings$fMonadQualifyqOrderings$fMonadRestrictrcOrderings$fMonadTransOrderings$fMonadOrderings$fFunctorOrderings$fApplicativeOrderings QueryJoinjoin'unsafeSubQueryWithAttrextractProduct$fMonadQueryQueryJoin$fMonadQualifyqQueryJoin$fMonadTransQueryJoin$fMonadQueryJoin$fFunctorQueryJoin$fApplicativeQueryJoin OrderedQuery QueryCore extractCore QueryUniqueunsafeUniqueSubQuery$fMonadQualifyQueryUnique$fMonadQueryQueryUnique$fMonadQueryUnique$fApplicativeQueryUnique$fFunctorQueryUnique SimpleQuery QuerySimplesimple AssignTarget Assignings assigningsassignTo<-#extractAssignments$fMonadQualifyqAssignings$fMonadRestrictcAssignings$fMonadTransAssignings$fMonadAssignings$fFunctorAssignings$fApplicativeAssigningsRegisterAssignPartitioningSetAggregatingSetListAggregatingPowerSetAggregatingSetPartitioningSetTAggregatingPowerSetTAggregatingSetListTAggregatingSetT Aggregatings aggregatingsextractAggregateTermskeykey'setbkeyrollupcube groupingSets$fMonadAggregateAggregatings$fMonadQueryAggregatings$fMonadQualifyqAggregatings$fMonadRestrictcAggregatings$fMonadPartitioncAggregatings$fMonadTransAggregatings$fMonadAggregatings$fFunctorAggregatings$fApplicativeAggregatingsWindowAggregatedQueryQueryAggregateover$fMonadRestrictFlatRestrictingsUniqueRelationderivedRelationtableOfquery queryMaybe queryList' queryList relation'relationaggregateRelation'aggregateRelation unsafeUniqueunUnique uniqueQuery'uniqueQueryMaybe'uniqueRelation'aggregatedUnique queryScalar' queryScalarJoinRestrictioninner'left'right'full'innerleftrightfullon'unionAll exceptAll intersectAllunion' unionAll'except' exceptAll' intersect' intersectAll' InsertTarget UpdateTarget Restriction restriction restriction'sqlWhereFromRestriction updateTarget updateTarget'liftTargetAllColumnliftTargetAllColumn'updateTargetAllColumnupdateTargetAllColumn'sqlFromUpdateTarget insertTarget insertTarget' piRegistersqlChunkFromInsertTargetsqlFromInsertTargetsqlChunksFromRecordList$fShowRestriction$fShowUpdateTargetUntypeableNoFetch untypeNoFetchDelete untypeDelete InsertQueryuntypeInsertQueryInsert untypeInsert chunkedInsertUpdate untypeUpdate KeyUpdate updateKeyuntypeKeyUpdateQuery untypeQueryunsafeTypedQueryrelationalQuerySQLrelationalQuery'relationalQueryunsafeTypedKeyUpdatetypedKeyUpdatetypedKeyUpdateTable keyUpdatederivedKeyUpdateunsafeTypedUpdate updateSQL typedUpdate' typedUpdateupdate'derivedUpdate'update updateNoPH derivedUpdatetypedUpdateAllColumnupdateAllColumn'derivedUpdateAllColumn'updateAllColumnupdateAllColumnNoPHderivedUpdateAllColumnuntypeChunkInsertchunkSizeOfInsertunsafeTypedInsert'unsafeTypedInsert typedInsert' typedInsertinsert derivedInserttypedInsertValue'typedInsertValue insertValue'derivedInsertValue' insertValueinsertValueNoPHderivedInsertValueinsertValueList'insertValueListunsafeTypedInsertQueryinsertQuerySQLtypedInsertQuery'typedInsertQuery insertQueryderivedInsertQueryunsafeTypedDelete deleteSQL typedDelete' typedDeletedelete'derivedDelete'delete deleteNoPH derivedDelete $fShowQuery$fShowKeyUpdate $fShowUpdate $fShowInsert$fShowInsertQuery $fShowDelete$fUntypeableNoFetchDelete$fUntypeableNoFetchUpdate$fUntypeableNoFetchInsertQuery$fUntypeableNoFetchInsertNumberBindingbinding SeqBinding boundTableboundKey boundSequenceSequenceDerivablederivedSequenceSequenceseqTable seqExtractseqKeyunsafeSpecifySequence seqRelationunsafeSpecifyBindingprimaryBinding fromRelationunsafeSpecifyNumber extractNumber$$!$$ updateNumber' updateNumber $fEqNumber $fOrdNumber $fShowNumber specifiedKeyuniqueprimary'primaryupdateValuesWithKeyupdateByConstraintKey primaryUpdatederivedUniqueRelationdefineHasPrimaryKeyInstance%defineHasPrimaryKeyInstanceWithConfigdefineHasNotNullKeyInstance%defineHasNotNullKeyInstanceWithConfig defineColumnsdefineOverloadedColumnsdefineColumnsDefaultdefineOverloadedColumnsDefaultdefineTableTypesderivationExpDefaulttableVarExpDefaultrelationVarExpdefineTableTypesWithConfigdefineTableTypesAndRecorddefinePrimaryQuerydefinePrimaryUpdatedefineSqlsWithPrimaryKeydefineSqlsWithPrimaryKeyDefault defineTableunsafeInlineQuery reifyRelation inlineQuerymakeRelationalRecordDefault'makeRelationalRecordDefaultProjectableShowSqlSqlProjectableProjectableIdZipProjectableApplicativeProjectableFunctorListProjection ProjectionrightIdleftIdpfmappappzero$fSqlProjectableRecord$fProjectableShowSqlRecordQueryA queryExists queryExists' queryListU queryListU' queryScalarU queryScalarU'assign$fCategoryQueryA $fArrowQueryADatabase.Record.TH'names-th-0.2.0.4-HUrPKfOIKAb9r5qmKDpWA6"Language.Haskell.TH.Name.CamelCasevarCamelcaseName stringSQLbaseGHC.BaseString showStringSQL rowStringSQLrowPlaceHolderStringSQLrowConsStringSQL listStringSQLboolSQLUntypedname' columnArraycolumns'transformers-0.5.2.0Control.Monad.Trans.ReaderReaderTPi'unsafeCastRecordWidthmap definePi'Database.Record.PersistablePersistableRecordWidthrunPiLeftestMap KeyConstraintunsafeReturnKey mapConstraintGShowConstantTermsSQLgShowConstantTermsSQLdefineTupleShowConstantInstancedefineRecordProjections intTermsSQLescapeStringToSqlExpr stringExprSQL time-1.8.0.2 Data.Time.Clock.Internal.UTCTimeUTCTime&Data.Time.LocalTime.Internal.ZonedTime ZonedTime&Data.Time.LocalTime.Internal.LocalTime LocalTime&Data.Time.LocalTime.Internal.TimeOfDay TimeOfDayData.Time.Calendar.DaysDayghc-prim GHC.TypesDoubleFloatBoolChar#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.Internal.LazyTextData.Text.Internalbytestring-0.10.8.2Data.ByteString.Lazy.Internal ByteStringData.ByteString.InternalIntGHC.IntInt64Int32Int16Int8 whenClauses growRightrestrictProduct'showsDuplication showQualifier columnFromIdqualifiedSQLasfromTableToSQLfromTableToNormalizedSQLselectPrefixSQL normalizedSQLtoSQLsindexWhensClause caseClause showColumnshowTupleIndexshowsQueryProductshowsJoinProductcomposeRestrictQualifyevalQualifyPrimenewAlias JoinContextprimeJoinContext updateProduct joinProductproduct unsafeProjectListSub updateSQL'updateOtherThanKeySQL'deletePrefixSQL' compareBinOp monoBinOp monoBinOp'unsafeCastPlaceHoldersGHC.OverloadedLabelsIsLabelPiLabelGetPimonomorphicProjectionpolymorphicProjectionstupleProjectionupdateRestrictionupdateOrderBysControl.Monad.Trans.State.LazyStateT updateContextupdateJoinRestriction queryWithAttruniqueQueryWithAttrjoin_typedUpdateAllColumn'defineHasConstraintKeyInstancedefineTableDerivableInstancedefineTableDerivations*defineProductConstructorInstanceWithConfigdefineWithPrimaryKeydefineWithNotNullKeyWithConfigprojectionTemplateProductIsoEmptyProductIsoApplicativeProductIsoFunctorpeRightpeLeftpureE