úΏyàÉ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿ÀÁÂÃÄÅÆÇÈNone %&9;<=DIQRfNormalized append of two inductive tuples. Note that this will flatten any nested inductive tuples. AAn inductively defined "tuple", or heterogeneous, non-empty list. Name of a database table. Name of a database column. ,Get the first element of an inductive tuple.-Get the second element of an inductive tuple.,Get the third element of an inductive tuple.-Get the fourth element of an inductive tuple.,Get the fifth element of an inductive tuple.,Get the sixth element of an inductive tuple..Get the seventh element of an inductive tuple.-Get the eighth element of an inductive tuple.,Get the ninth element of an inductive tuple.,Get the tenth element of an inductive tuple.É ÊËÌÍÎÏÐÉ É  ÊËÌÍÎÏÐ 1 1Safe%&9;T(Some value that is representable in SQL.An SQL literal.'6Any datatype representable in (Selda's subset of) SQL.(VFormat string used to represent date and time when talking to the database backend.)MFormat string used to represent date when talking to the database backend.*TFormat string used to represent time of day when talking to the database backend.Ñ8Constructor tag for all literals. Used for Ord instance.Ò4Compare two literals of different type for equality.% !"#$%&'ÓÔÕ()*ÑÒÖרÙÚÛÜÝÞßàá !"#$%&'ÓÔÕ()*ÑÒ  !"#$%&'ÓÔÕ()*ÑÒÖרÙÚÛÜÝÞßàáNone 9;DQRT+1An inductive tuple forming a table specification.,@An inductive tuple where each element is a column specification.-ÖColumn attributes such as nullability, auto increment, etc. When adding elements, make sure that they are added in the order required by SQL syntax, as this list is only sorted before being pretty-printed.2#Any SQL type which is NOT nullable.3Is the given type nullable?4Used by 3 to indicate a nullable type.5Used by 3 to indicate a nullable type.6A table column specification.7­A database table. Tables are parameterized over their column types. For instance, a table containing one string and one integer, in that order, would have the type Table (Text :*: Int)L, and a table containing only a single string column would have the type  Table Text.â9Name of the table. NOT guaranteed to be a valid SQL name.ã%All table columns. Invariant: the ä= list of each column is sorted and contains no duplicates.8*A non-nullable column with the given name.9&A nullable column with the given name.:¥Marks the given column as the table's primary key. A table may only have one primary key; marking more than one key as primary will result in a run-time error.;]Automatically increment the given attribute if not specified during insert. Also adds the  PRIMARY KEY attribute on the column.å9Add an attribute to a column. Not for public consumption.<(A table with the given name and columns.æRemove duplicate attributes.ç.Sort a list and remove all duplicates from it.è/Sort a list, then group all identical elements.é@Ensure that there are no duplicate column names or primary keys.&+ê,-./0123456ëìíîïðä7ñâãò89:;å<æçèéóôõ#+ê,-./0123456ëìíîïðä7ñâãò89:;å<æçèé+ê,-./0123456ëìíîïðä7ñâãò89:;å<æçèéóôõNone@ Compile a  CREATE TABLE query from a table definition.öCompile a table column.A Compile a  DROP TABLE query.÷ Compile an  INSERT INTO query inserting m rows with nW cols each. Note that backends expect insertions to NOT have a semicolon at the end.BCompile a column attribute.=>?@öA÷B=>?@öA÷B=>?@öA÷B None %&+9;DQR øDUnderlying column expression type, not tied to any particular query.CŠA database column. A column is often a literal column table, but can also be an expression over such a column or a constant expression.ùJA type-erased column, which may also be renamed. Only for internal use.DAny column tuple.E<Convert a tuple of Haskell types to a tuple of column types.FA literal expression.GÿA unary operation. Note that the provided function name is spliced directly into the resulting SQL query. Thus, this function should ONLY be used to implement well-defined functions that are missing from Selda's standard library, and NOT in an ad hoc manner during queries.HLike G, but with two arguments.ú-Get all column names in the given expression.7ûüýþÿ     øCùDEFGHú !"#$%&'(.ûüýþÿ     øCùDEFGHúû üýþÿ     øCùDEFGHú !"#$%&'( None9:;DQRIOne or more aggregate columns.JtThe results of a join are always nullable, as there is no guarantee that all joined columns will be non-null.  JoinCols a where av is an extensible tuple is that same tuple, but in the outer query and with all elements nullable. For instance: b JoinCols (Col (Inner s) Int :*: Col (Inner s) Text) = Col s (Maybe Int) :*: Col s (Maybe Text)KNConvert one or more inner column to equivalent columns in the outer query. GOuterCols (Aggr (Inner s) a :*: Aggr (Inner s) b) = Col s a :*: Col s b, for instance.L¢Denotes an inner query. For aggregation, treating sequencing as the cartesian product of queries does not work well. Instead, we treat the sequencing of  aggregate{ with other queries as the cartesian product of the aggregated result of the query, a small but important difference.ŠHowever, for this to work, the aggregate query must not depend on any columns in the outer product. Therefore, we let the aggregate query be parameterized over Inner s+ if the parent query is parameterized over s , to enforce this separation.MnA single aggregate column. Aggregate columns may not be used to restrict queries. When returned from an  aggregateK subquery, an aggregate column is converted into a non-aggregate column.N+Create a named aggregate function. Like Gs, this function is generally unsafe and should ONLY be used to implement missing backend-specific functionality. I)JKLM*+N,- I)JKLM*+NI)JKLM*+N,- None %&9;QRO1An inductive tuple of Haskell-level values (i.e. Int :*: Maybe Text() which can be inserted into a table..eException indicating the use of a default value. If any values throwing this during evaluation of param xs, will be replaced by their default value.P(A parameter to a prepared SQL statement.R'The order in which to sort result rows./AST for SQL queries.0A source for an SQL query.O1.2PQRST/34567890:;<=>?@ABCDO1.2PQRST/34567890;:<=> O1.2PQRST/34567890:;<=>?@ABCD NoneIEÐSQL generation internal state. Contains the subqueries and static (i.e. not dependent on any subqueries) restrictions of the query currently being built, as well as a name supply for column renaming.U An SQL query.F.Run a query computation from an initial state.GJRun a query computation in isolation, but reusing the current name supply.H.Initial state: no subqueries, no restrictions.I,Generate a unique name for the given column.J#Get a guaranteed unique identifier.K$Get a guaranteed unique column name.ELMNOPUQRFGHIJKELPMNOUQRFGHIJKELMNOPUQRFGHIJK None%& SYSQL pretty-printer. The state is the list of SQL parameters to the prepared statement.TO(n log n) equivalent of  nub . sortURun a pretty-printer.V2Compile an SQL AST into a parameterized SQL query.W#Compile a single column expression.X Compile an UPATE statement.Y Compile a DELETE statement.ZbPretty-print a literal as a named parameter and save the name-value binding in the environment.[&Generate a unique name for a subquery.\Pretty-print an SQL AST.]^_`abSTUVWXYZc[\defgh]^_`abSTUVWXYZc[\defgh]^_`abSTUVWXYZc[\defghNonei„Remove all dead columns recursively, assuming that the given list of column names contains all names present in the final result.j^Return the names of all columns in the given top-level query. Subqueries are not traversed.k)Return the names of all non-output (i.e. 4H) columns in the given top-level query. Subqueries are not traversed.lRGet all column names appearing in the given list of (possibly complex) columns.mÿ_Remove all columns but the given, named ones and aggregates, from a query's list of outputs. If we want to refer to a column in an outer query, it must have a name. If it doesn't, then it's either not referred to by an outer query, or the outer query duplicates the expression, thereby referring directly to the names of its components.niBuild the outermost query from the SQL generation state. Groups are ignored, as they are only used by  aggregate.o/Get all output columns from a list of SQL ASTs.ijklmnoijklmnoijklmnoNone %&9:;DQRT VOAn acceptable query result type; one or more columns stitched together with :*:.pConverts the given list of SqlValue1s into an tuple of well-typed results. See  querySQLiteb for example usage. The given list must contain exactly as many elements as dictated by the Res r. If the result is  a :*: b :*: cC, then the list must contain exactly three values, for instance.q4Produce a list of all columns present in the result.X3Compile a query into a parameterised SQL statement.rhCompile a query into a parameterised SQL statement. Also returns all tables depended on by the query.Y Compile an INSERTŽ query, given the keyword representing default values in the target SQL dialect, a table and a list of items corresponding to the table.Z Compile an UPDATE query.s Compile a  DELETE FROM query.tOCompile a query to an SQL AST. Groups are ignored, as they are only used by  aggregate. VWpqXrYZThe table to update.Update function.!Predicate: update only when true.stuv VWqpXrYZst VWpqXrYZstuvNone:[IQuery the given table. Result is returned as an inductive tuple, i.e. 0first :*: second :*: third <- query tableOfThree.\Query an ad hoc table of type aK. Each element in the given list represents one row in the ad hoc table.]2Restrict the query somehow. Roughly equivalent to WHERE.^iExecute a query, returning an aggregation of its results. The query must return an inductive tuple of  Aggregate columns. When  aggregatez returns, those columns are converted into non-aggregate columns, which may then be used to further restrict the query.€Note that aggregate queries must not depend on outer queries, nor must they return any non-aggregate columns. Attempting to do either results in a type error.The SQL HAVING) keyword can be implemented by combining  aggregate and ]: ÿ-- Find the number of people living on every address, for all addresses -- with more than one tenant: -- SELECT COUNT(name) AS c, address FROM housing GROUP BY name HAVING c > 1 numPpl = do num_tenants :*: address <- aggregate $ do _ :*: address <- select housing groupBy address return (count address :*: some address) restrict (num_tenants .> 1) return (num_tenants :*: address)_ Perform a  LEFT JOIN‡ with the current result set (i.e. the outer query) as the left hand side, and the given query as the right hand side. Like with ^L, the inner (or right) query must not depend on the outer (or right) one.³The given predicate over the values returned by the inner query determines for each row whether to join or not. This predicate may depend on any values from the outer query.6For instance, the following will list everyone in the peopled table together with their address if they have one; if they don't, the address field will be NULL. ígetAddresses :: Query s (Col s Text :*: Col s (Maybe Text)) getAddresses = do name :*: _ <- select people _ :*: address <- leftJoin (\(n :*: _) -> n .== name) (select addresses) return (name :*: address)`ÿ#Group an aggregate query by a column. Attempting to group a non-aggregate query is a type error. An aggregate representing the grouped-by column is returned, which can be returned from the aggregate query. For instance, if you want to find out how many people have a pet at home: taggregate $ do name :*: pet_name <- select people name' <- groupBy name return (name' :*: count(pet_name) > 0)aDrop the first m rows, then get at most n of the remaining rows.bGSort the result rows in ascending or descending order on the given row.[\]^_GPredicate determining which lines to join. | Right-hand query to join.`ab[\]^_`ab[\]^_`abNonecsCast a column to another type, using whichever coercion semantics are used by the underlying SQL implementation.cGHNcGHNccNone%&T wQuery to result mapping.xUTable to query mapping, for keeping track of which queries depend on which tables.yItems currently in cache.zMax number of items in cache.{Next cache prio to use.|9Cache the given value, with the given table dependencies.}5Get the cached value for the given key, if it exists.~=Invalidate all items in cache that depend on the given table.5Set the maximum number of items allowed in the cache.€wxyz{‚ƒ„|…}†~‡ˆ‰Š‚|}~€wxyz{‚ƒ„|…}†~‡ˆ‰ŠNoneI d0Monad transformer adding Selda SQL capabilities.g(Some monad with Selda SQL capabilitites.h*Get the backend in use by the computation.i4A collection of functions making up a Selda backend.kExecute an SQL statement.l®Execute an SQL statement and return the last inserted primary key, where the primary key is auto-incrementing. Backends must take special care to make this thread-safe.mcGenerate a custom column type for the column having the given Selda type and list of attributes.nTThe keyword that represents the default value for auto-incrementing primary keys.oŒA function which executes a query and gives back a list of extensible tuples; one tuple per result row, and one tuple element per column.pHRun a Selda transformer. Backends should use this to implement their withX functions.defghijklmnopq* !"#$%&()*-./01BPQdefghijmnklop*oijklmnghdefPQ !"#$%&-./01B()*pdefghijklmnopqNone:Tz?Run a query within a Selda monad. In practice, this is often a de transformer on top of some other monad. Selda transformers are entered using backend-specific withX functions, such as  withSQLite from the SQLite backend.{šInsert the given values into the given table. All columns of the table must be present. If your table has an auto-incrementing primary key, use the special value defl for that column to get the auto-incrementing behavior. Returns the number of rows that were inserted.KTo insert a list of tuples into a table with auto-incrementing primary key: ÿYpeople :: Table (Auto Int :*: Text :*: Int :*: Maybe Text) people = table "ppl" $ autoPrimary "id" € required "name" € required "age" € optional "pet" main = withSQLite "my_database.sqlite" $ do insert_ people [ def :*: "Link" :*: 125 :*: Just "horse" , def :*: "Zelda" :*: 119 :*: Nothing , ... ]|Like {i, but does not return anything. Use this when you really don't care about how many rows were inserted.}Like {£, but returns the primary key of the last inserted row. Attempting to run this operation on a table without an auto-incrementing primary key is a type error.~‰Update the given table using the given update function, for all rows matching the given predicate. Returns the number of updated rows.Like ~0, but doesn't return the number of updated rows.€jFrom the given table, delete all rows matching the given predicate. Returns the number of deleted rows.Like €1, but does not return the number of deleted rows.‚%Create a table from the given schema.ƒ?Create a table from the given schema, unless it already exists.„Drop the given table.…#Drop the given table, if it exists.†šPerform the given computation atomically. If an exception is raised during its execution, the enture transaction will be rolled back, and the exception re-thrown.‡$Set the maximum local cache size to nr. A cache size of zero disables local cache altogether. Changing the cache size will also flush all entries.(By default, local caching is turned off.ÿÿWARNING: local caching is guaranteed to be consistent with the underlying database, ONLY under the assumption that no other process will modify it. Also note that the cache is shared between ALL Selda computations running within the same process.‹5Build the final result from a list of result columns.ŒHGenerate the final result of a query from a list of untyped result rows.hRun the given computation over a table after invalidating all cached results depending on that table.Ž%Execute a statement without a result.z{|}~The table to update. Predicate.Update function.€‚ƒ„…†‡‹ŒŽVWdghz{|}~€‚ƒ„…†‡z{|}~€‚ƒ„…†‡‹ŒŽNone9;ˆ*Any column type that can be used with the   and Ÿ functions.Is the given column null?’ Ordering for b.“ Ordering for b.”|The default value for a column during insertion. For an auto-incrementing primary key, the default value is the next key.Using defQ in any other context than insertion results in a runtime error. Likewise, if defV is given for a column that does not have a default value, the insertion will fail.•gLift a non-nullable column to a nullable one. Useful for creating expressions over optional columns: âpeople :: Table (Text :*: Int :*: Maybe Text) people = table "people" $ required "name" € required "age" € optional "pet" peopleWithCats = do name :*: _ :*: pet <- select people restrict (pet .== just "cat") return name–SQL NULL, at any type you like.—Specialization of F for integers.˜Specialization of F for doubles.™Specialization of F for text.š True and false boolean literals.› True and false boolean literals.œThe SQL LIKE operator; matches strings with % wildcards. For instance: "%gon" `like` "dragon" .== true2The number of non-null values in the given column.ž.The average of all values in the given column.ŸEThe greatest value in the given column. Texts are compared lexically. EThe smallest value in the given column. Texts are compared lexically.¡#Sum all values in the given column.¢4Round a value to the nearest integer. Equivalent to  roundTo 0.£6Round a column to the given number of decimals places.€(Calculate the length of a string column.¥Boolean negation.Š-Convert a boolean column to any numeric type.§.Convert an integer column to any numeric type.šConvert any column to a string.$ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¥Š§š©ª«u '+,23456789:;<=>?@ACDEFIJKLMORSTUVWXYZ[\]^_`abdgz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¥Š§šugd7UCVWz†‡'EDRST [\]ab’“‰Š‹ŒŽœ‘¥F—˜™š›–£€¢•ЧšMIKJLˆ_^`ž¡Ÿ O{|}”~€+,6 2354<89:;‚ƒ„…=>?X@AYZ $ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¥Š§š©ª« ‰4Š4‹4Œ44Ž43‘2œ4None%&*9:;<=DQRTIConvert a value to a Haskell type from the type's corresponding relation.FConvert a value from its Haskell type into the corresponding relation.‘7Compute all columns needed to represent the given type.’6Create a dummy value where all fields are replaced by  unsafeCoerce'd ints. See “ and ” for more information.•-The relation corresponding to the given type.–YA dummy of some type. Encapsulated to avoid improper use, since all of its fields are —d ints.¬1Some attribute that may be set on a table column.­UA generic column attribute. Essentially a pair or a record selector over the type a and a column attribute.¯žThe relation corresponding to the given Haskell type. This relation simply corresponds to the fields in the data type, from left to right. For instance: 1data Foo = Foo { bar :: Int , baz :: Text }In this example,  Relation Foo is (Int :*: Text), as the first field of Foo has type Int, and the second has type Text.°,A generic table. Needs to be unpacked using gen before use with [, {, etc.³:Any type which has a corresponding relation. To make a  Relational' instance for some type, simply derive .dNote that only types which have a single data constructor, and where all fields are instances of ® can be used with this module. Attempting to use functions in this module with any type which doesn't obey those constraints will result in a very confusing type error.ŽQGenerate a table from the given table name and list of column attributes. All MaybeT fields in the table's type will be represented by nullable columns, and all non-MaybeC fields fill be represented by required columns. For example: Âdata Person = Person { id :: Int , name :: Text , age :: Int , pet :: Maybe Text } deriving Generic people :: GenTable Person people = genTable "people" [(name, autoPrimaryGen)]:This example will create a table with the column types #Int :*: Text :*: Int :*: Maybe Text?, where the first field is an auto-incrementing primary key.µ¬Convert a generic type into the corresponding database relation. A type's corresponding relation is simply the inductive tuple consisting of all of the type's fields. Ûdata Person = Person { id :: Int , name :: Text , age :: Int , pet :: Maybe Text } deriving Generic somePerson = Person 0 "Velvet" 19 Nothing (theId :*: theName :*: theAge :*: thePet) = toRel somePerson?This is mainly useful when inserting values into a table using {! and the other functions from Database.Selda.¶Re-assemble a generic type from its corresponding relation. This can be done either for ad hoc queries or for queries over generic tables: ÿdata SimplePerson = SimplePerson { name :: Text , age :: Int } deriving Generic demoPerson :: SimplePerson demoPerson = fromRel ("Miyu" :*: 10) adhoc :: Table (Text :*: Int) adhoc = table "adhoc" $ required "name" € required "age" getPersons1 :: MonadSelda m => m [SimplePerson] getPersons1 = map fromRel <$> query (select adhoc) generic :: GenTable SimplePerson generic = genTable "generic" [] getPersons2 :: MonadSelda m => m [SimplePerson] getPersons2 = map fromRel <$> query (select (gen generic)) Applying toReld to an inductive tuple which isn't the corresponding relation of the return type is a type error.·Like }A, but accepts a generic table and its corresponding data type.žLike {>, but accepts a generic table and its corresponding data type.¹Like |>, but accepts a generic table and its corresponding data type.ºjFrom the given table column, get the column corresponding to the given selector function. For instance: ÿ data Person = Person { id :: Int , name :: Text , age :: Int , pet :: Maybe Text } deriving Generic people :: Table Person people = genTable "people" [name :- primary] getAllAges :: Query s Int getAllAges = do p <- select people return (p ! age)¯Note that ONLY selector functions may be passed as the second argument of this function. Attempting to pass any non-selector function results in a Haskell runtime error.»,A primary key which does not auto-increment.Œ!An auto-incrementing primary key.˜hExtract all column names from the given type. If the type is not a record, the columns will be named col_1, col_2, etc.“!Create a dummy of the given type.”FGet the selector identifier of the given selector for the given dummy..™š›œ‘’•ž–Ÿ¬ ­®¯°±²³Žµ¶·ž¹º»Œ˜“”œŸ¿ÀÁÂÃÄÅÆÇȬ­®¯°±²³Žµ¶·ž¹º»Œ³­®°±²¬¯Žµ¶ºž¹·»Œ#™š›œ‘’•ž–Ÿ¬ ­®¯°±²³Žµ¶·ž¹º»Œ˜“”œŸ¿ÀÁÂÃÄÅÆÇÈ¡ !!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \ ] ^ _ ` a b c d e f g g h i j klmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿ÀÁÂÃÄÅÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖרÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþMÿN                         Z ! 4   " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 d 7 8 9 : ; < = : ; > ? @ A B C " D E F G H I J K L M N O P Q R S T N U V W X k Y Z û [ \ ] ^ _ ` a b c c d e f g h i j k l mnopqrstuvwxyz{|}~€‚ƒ„……†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£šÁ€$selda-0.1.2.0-1cvW5ZFtKFEJtjnJq5NySfDatabase.Selda.GenericDatabase.Selda.BackendDatabase.SeldaDatabase.Selda.UnsafeDatabase.Selda.TypesDatabase.Selda.SqlTypeDatabase.Selda.TableDatabase.Selda.Table.CompileDatabase.Selda.ColumnDatabase.Selda.InnerDatabase.Selda.SQLDatabase.Selda.Query.TypeDatabase.Selda.SQL.PrintDatabase.Selda.TransformDatabase.Selda.CompileDatabase.Selda.QueryDatabase.Selda.CachingDatabase.Selda.Frontendbase GHC.GenericsGenericControl.Monad.IO.ClassliftIOMonadIO#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.InternalTextAppendapp:++:TupHead:*: TableNameColNamefirstsecondthirdfourthfifthsixthseventheighthninthtenthSqlValueSqlIntSqlFloat SqlStringSqlBoolSqlNullLitLitSLitILitDLitBLitTSLitDateLitTimeLitJustLitNullSqlTypesqlDateTimeFormat sqlDateFormat sqlTimeFormat TableSpecColSpecsColAttrPrimary AutoIncrementRequiredOptionalNonNull IsNullable NotNullableNullableColSpecTablerequiredoptionalprimary autoPrimarytableOnErrorFailIgnorecompileCreateTablecompileDropTablecompileColAttrColColumnsColsliteralfunfun2 AggregatesJoinCols OuterColsInnerAggraggrInsertParamOrderAscDescQueryResultRescompile compileInsert compileUpdateselect selectValuesrestrict aggregateleftJoingroupBylimitordercastSeldaTSunS MonadSelda seldaBackend SeldaBackendrunStmt runStmtWithPK customColTypedefaultKeyword QueryRunner runSeldaT$fMonadSeldaSeldaT$fFunctorSeldaT$fApplicativeSeldaT $fMonadSeldaT$fMonadIOSeldaT$fMonadThrowSeldaT$fMonadCatchSeldaT$fMonadMaskSeldaT$fMonadTransSeldaTqueryinsertinsert_ insertWithPKupdateupdate_ deleteFrom deleteFrom_ createTabletryCreateTable dropTable tryDropTable transaction setLocalCacheMinMax.==./=.>.<.>=.<=isNull.&&.|| ascending descendingdefjustnull_intfloattexttruefalselikecountavgmax_min_sum_round_roundTolength_not_fromBoolfromInttoString $fMinMaxMaybe $fMinMaxText $fMinMaxa AttributeGenAttr:-RelationGenTablegen RelationalgenTabletoRelfromRelinsertGenWithPK insertGen insertGen_! primaryGenautoPrimaryGen $fGFromRelM1 $fGFromRelK1 $fGFromRel:*:$fToDyna $fToDyn:*:$fGRelation:*: $fGRelationK1 $fGRelationM1$fGRelationM10$fGRelationM11 $fTraitsa $fTraitsMaybetupHead $fAppendab $fAppend:*:c$fTupa$fTup:*:$fOrd:*:$fEq:*: $fShow:*: litConTagcompLitmkLitsqlTypefromSql$fSqlTypeMaybe$fSqlTypeTimeOfDay $fSqlTypeDay$fSqlTypeUTCTime $fSqlTypeBool $fSqlTypeText$fSqlTypeDouble $fSqlTypeInt $fShowLit$fShowSqlValue$fOrdLit$fEqLit tableName tableColscolAttrsaddAttrtidysnubsoupvalidate mergeSpecsunCSColInfocolNamecolTypenewCol $fTableSpeca$fTableSpec:*: $fNonNullacompileTableCol compInsertExpSomeCol allNamesInBinOpGtLtGteLteEqNeqAndOrAddSubMulDivLikeUnOpAbsNotNegSgnIsNullFunTblColFun2CastAggrExCunCSomeNamedtoTupfromTupliftC2liftC$fFractionalCol$fFractionalCol0$fFractionalCol1$fFractionalCol2$fNumCol $fNumCol0 $fIsStringCol $fColumnsCol $fColumns:*:unAggrsunAggr$fAggregates:*:$fAggregatesAggrDefaultValueExceptionSQL SqlSourceparamscolssource restrictsgroupsorderinglimitsProductLeftJoinValues EmptyTable $fInserta $fInsert:*: $fExceptionDefaultValueException $fOrdParam $fEqParam $fShowParamGenState runQueryMisolate initStaterenamefreshId freshNamesourcesstaticRestricts groupCols nameSupplyunQPPrunPPcompSqlcompExp compUpdate compDeleteppLitfreshQueryNameppSqlPPStateppParamsppTables ppParamNS ppQueryNSdependOn ppSomeColppColsppColppUnOpppBinOpremoveDeadCols allColNamesallNonOutputColNamescolNameskeepCols state2sqlallColstoRes finalColscompileWithTables compileDelete compQuery $fResultCol $fResult:*:resultsdepsitemsmaxItemsnextPriocachecached invalidate setMaxItems ResultCacheCacheKey emptyCachetheCachecache'cached' invalidate' setMaxItems' $fHashableLit$fHashableParam queryWith mkResults withInvalexecgFromRelgToRelgTblColsgMkDummymkDummyidentifyRelDummy Unsafe.Coerce unsafeCoercetblColsGFromRelToDyntoD GRelationTraits isMaybeType