h.[II      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                               1.8.0.0 None&rsxyz{|}~mnopq'( Il YJ HKLMNOPQRSZ[\]^_X/0?@ABCDE7)*+,-.456123vw"#$%&;<=>89:ijktu/0123456ijkCD?@ABFGE)*+,-."#$%&'(tuvw>=<;IKLMNOPQRSTUVWJXrslqmnop |7}~xyz{:_\]Z[^Y 89 HNone#d a as tests whether a is an element of the list as. a as tests whether a& is an element of the non-empty list as. a as tests whether a is not an element of the list as. a as tests whether a* is not an element of the non-empty list as.NoneNone ! !None # Round a < to a =, by rounding to the nearest larger integer.Corresponds to the  ceiling() function./Emulates the behaviour of the Haskell function   in PostgreSQL. Simultaneous  and .Round a  DFractional to a =. by rounding to the nearest smaller integer. Corresponds to the floor() function.Cast = types to > types. For example, this can be useful if you need to turn an  Expr Int32 into an  Expr Double./Emulates the behaviour of the Haskell function   in PostgreSQL..Perform integral division. Corresponds to the div()7 function in PostgreSQL, which behaves like Haskell's   rather than  . Simultaneous  and .Cast > types to <4 types. For example, this can be useful to convert  Expr Float to  Expr Double.Corresponds to the mod()7 function in PostgreSQL, which behaves like Haskell's   rather than  .Round a < to a =% by rounding to the nearest integer.Corresponds to the round() function.Round a < to a =2 by rounding to the nearest integer towards zero.  None++None#:Move forward a given number of days from a particular day.Add a time interval to a point in time, yielding a new point in time.An interval of one day.0Create a literal interval from a number of days.=Find the number of days between two days. Corresponds to the - operator.$Find the duration between two times.Corresponds to x::timestamptz.An interval of one hour.1Create a literal interval from a number of hours.An interval of one minute.3Create a literal interval from a number of minutes.An interval of one month.2Create a literal interval from a number of months.Corresponds to now().An interval of one second.3Create a literal interval from a number of seconds.2Subtract a given number of days from a particular . Subtract a time interval from a point in time, yielding a new point in time.Corresponds to calling the date function with a given time.Corresponds to  date(now()).An interval of one week.1Create a literal interval from a number of weeks.An interval of one year.1Create a literal interval from a number of years.Nonegh`abcdefgh`fdecab None &'()/2  Derive a  instance using TemplateHaskell. Using TH can be signficantly faster than using Generics. Currently, this doesn't support all of the features of the Generics deriving machinery.You might have to enable UndecidableInstances for instances to compile.data Foo f = Foo { fooId :: Column f Word64 , fooName :: Column f Text } deriveRel8able ''FooLike  but for a list of datatypes. This is helpful as all of the instances live in a single splice. Each TH splice creates a new decleration group, so they cannot see instances later in the file. By deriving the instances in the same splice, we can ensure that they see each other. This is necessary when deriving cyclic instances, but also reduces the amount of splice sorting required. There is also a small performance overhead to each TH splice.Represent a valid datatypeRepresent a valid fieldLike foldr1, but we create a mostly balanced binary tree. This makes a big difference for compile times, since we want the depth of the HProduct tree to be minimal. Each layer adds a lot of overhead.2Generate an expression to construct a column value'Generate a pattern to destruct a column0Generate an expression to create the constructor+Generate a pattern to destruct the datatype6 but indicate that the failure is coming from our codeWalk  and replace all occurences of  Column f x with Expr x.66 None!#! produces a  where a single ()> row exists at every possible key that absent from the given .This is used to implement . produces a "magic" < whereby the values within each group of keys in the given  is aggregated according to the given aggregator, and every other possible key contains a single "fallback" row is returned, composed of the identity elements of the constituent aggregation functions.- aggregates the values within each key of a . There is an implicit GROUP BY on all the key columns. Performs a NATURAL FULL OUTER JOIN! based on the common key columns. Analogous to . Performs a NATURAL FULL OUTER JOIN! based on the common key columns. Analogous to .7 returns a count of how many entries are in the given  at each key.The resulting  is "magic" in that the value 08 exists at every possible key that wasn't in the given . Performs a  https://en.wikipedia.org/wiki/Relational_algebra#Antijoin_%28%E2%96%B7%29NATURAL ANTI JOIN" based on the common key columns.The result is a subset of the left tabulation where only entries which do not have a corresponding entry in the right tabulation are kept.0Note that you can achieve a similar effect with  and the  instance of , i.e., this is just #\left right -> left <* absent right. You can also use do -notation. ensures a  has at most one value for each key, i.e., it drops duplicates. In general it keeps only the "first" value it encounters for each key, but note that "first" is undefined unless you first call . produces a "magic"  which contains the value  at each key in the given , and the value  at every other possible key.Any  of key-value pairs (k, a) can be a  k a. Performs a NATURAL LEFT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just /\left right -> liftA2 (,) left (optional right). You can also use do -notation. Performs a NATURAL LEFT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just /\f left right -> liftA2 f left (optional right). You can also use do -notation.A  a can be treated as a  k a where the given a% values exist at every possible key k. k t! returns the value(s) at the key k in the tabulation t. aggregates each entry with a particular key into a single entry with all of the values contained in a . can be used to give this  a defined order.The resulting  is "magic" in that the value 'Rel8.listTable []'8 exists at every possible key that wasn't in the given . for s. produces a "magic" " whereby each entry in the given  is wrapped in 2, and every other possible key contains a single .This is used to implement . orders the values of a  within their respective keys. This specifies a defined order for 6. It also defines the order of the lists produced by  and . produces a  where a single ()9 row exists for every key that was present in the given .This is used to implement . Performs a NATURAL RIGHT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just 6\left right -> liftA2 (flip (,)) right (optional left). You can also use do -notation. Performs a NATURAL RIGHT OUTER JOIN! based on the common key columns. Analogous to  ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just 6\f left right -> liftA2 (flip f) right (optional left). You can also use do -notation. Performs a  https://en.wikipedia.org/wiki/Relational_algebra#Semijoin_%28%E2%8B%89%29%28%E2%8B%8A%29NATURAL SEMI JOIN" based on the common key columns.The result is a subset of the left tabulation where only entries which have a corresponding entry in the right tabulation are kept.0Note that you can achieve a similar effect with  and the  instance of , i.e., this is just $\left right -> left <* present right. You can also use do -notation. aggregates each entry with a particular key into a single entry with all of the values contained in a . can be used to give this  a defined order.Run a Kleisli arrow in the the  monad "through" a . Useful for !ing a . ! ((>=. 30) . userAge) `through' usersById  Convert a  k a back into a  of key-value pairs.Note that the result of a 1 is undefined (will always return zero rows) on s constructed with  or  . So while toQuery . fromQuery is always id, fromQuery . toQuery is not.)A safer, more predictable alternative to  is to use  with an explicit set of keys: ;do k <- keys a <- lookup k tabulation pure (k, a) 7Having said that, in practice, most legitimate uses of  will have a well-defined . It would be possible in theory to encode the necessary invariants at the type level using an indexed monad, but we would lose the ability to use do0-notation, which is the main benefit of having  as a monad in the first place.In particular,  t is well-defined for any  t defined as t = fromQuery _.  t is also well-defined for any  t defined as  t = t' >>= _ or  t = t' *> _ where  t' is well-defined. There are other valid permutations too. Generally, anything that uses / at some point, unless wrapped in a top-level  or , will have a well-defined . Performs a NATURAL INNER JOIN! based on the common key columns. Analagous to ".3Note that you can achieve the same effect with the  instance of , i.e., this is just  'liftA2 (,)'. You can also use do -notation. Performs a NATURAL INNER JOIN! based on the common key columns. Analagous to #.3Note that you can achieve the same effect with the  instance of , i.e., this is just . You can also use do -notation.A  k a is like a  a', except that each row also has a key k in addition to the value a. )s can be composed monadically just like *s, but the resulting join is more like a  NATURAL JOIN$ (based on the common key column(s) k ) than the  CROSS JOIN given by .Another way to think of  k a is as analogous to Map k a in the same way  a is analogous to [a]'. However, there's nothing stopping a  from containing multiple rows with the same key, so technically Map k (NonEmpty a) is more accurate.s can be created from s with  and  and converted back to s with  and 6 (though note the caveats that come with the latter).If  k a is Map k (NonEmpty a), then ( |:) is unionWith (<>). pure =  . pureIf  k a is Map k (NonEmpty a), then ( .) is intersectionWith (liftA2 ( *))If  k a is Map k (NonEmpty a), then (<>) is unionWith (liftA2 (<>)).s can be produced with either  or ?, and in some cases we might want to treat these differently.  uses  to determine which type of  we have.$ .$ 6$ 1$  $ +$ $ *$ "$ !$ +$ $ !$ $ $ $%&'%&(%&)%&*%&+%&,%&+-./-.0-.1-23-45-46-47-48-9:-9:-9:;-9:<-=>-=>-=>?-=>;-@A-@B-@B-@BC-@BD-@E-FG-FG-FGC-FGH-FGD-IJ-IJ-IJK-IJL-IJ;-MN-MO-MP-MP-MPQ-MPR-MPS-MPT-UV-UW-XY-XY-XYZ-[\-[\-[\]-^_-`a-`b-`c-de-df-dg-dh-ij-ik-il-im-in-in-io-ip-iq-rs-tu-vw-xy-xz-x{-x|-x}-x~-x-x-x-x-x-x-x---------------------------------------------------------------------?--------------------------------------Q-S--------------------------------------------------------------------------------------!-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                               " #                          -rel8-1.8.0.0-inplace Rel8.RangeRel8 Rel8.Decoder Rel8.Encoder Rel8.ArrayRel8.Expr.Text Rel8.Expr.NumRel8.Expr.TimeRel8.TH Rel8.Tabulaterel8PreludedivmodquotremTHTypesrc/Rel8/TH.hsData.Semialignalign alignWithtruefalserpadZip rpadZipWithQ materialize justTable nothingTablelpadZip lpadZipWithfilterzipzipWithsrc/Rel8/Tabulate.hspostgresql-binary-0.14.2-3bd926b3f626790c632a2f43707ef8b2859ab4784789013519c667fe78660bd5PostgreSQL.Binary.RangeBoundInclExclInfRangeEmptyrel8-internal-1.8.0.0-inplaceRel8.Internal.Aggregate.FoldFoldFullSemiRel8.Internal.OrderOrderRel8.Internal.Schema.Null HomonullableNotNullNullableSql"Rel8.Internal.Schema.QualifiedName QualifiedNamenameschemaRel8.Internal.Schema.Table TableSchemacolumnsRel8.Internal.Type.Decoder parseDecoderDecoderbinarytextParserRel8.Internal.Type.EncoderEncoderquoteRel8.Internal.Type.NameTypeName arrayDepth modifiersRel8.Internal.Type.InformationmapTypeInformationparseTypeInformationTypeInformationdecode delimiterencodetypeNameRel8.Internal.TypeDBTypetypeInformationRel8.Internal.Type.JSONEncoded JSONEncodedfromJSONEncodedRel8.Internal.Type.JSONBEncoded JSONBEncodedfromJSONBEncodedRel8.Internal.Type.EqDBEqRel8.Internal.Type.OrdDBMaxDBMinDBOrdRel8.Internal.Type.Num DBFloating DBFractional DBIntegralDBNumRel8.Internal.Type.EnumDBEnum enumTypeName enumValue enumerateEnumEnumable $dmenumValue $dmenumerateRel8.Internal.Schema.ResultResultRel8.Internal.ColumnColumnRel8.Internal.Schema.HTableHTableRel8.Internal.TableTableColumnsContext FromExprs Transpose fromColumns fromResult toColumnstoResult$dmfromColumns $dmfromResult $dmtoColumns $dmtoResultRel8.Internal.Table.Transpose TransposesRel8.Internal.Schema.FieldFieldRel8.Internal.Table.Projection Biprojectable biproject Projectableproject Projecting ProjectionRel8.Internal.Type.RangeDBRangemultirangeDecodermultirangeEncodermultirangeTypeName rangeDecoder rangeEncoder rangeTypeNameRel8.Internal.Data.Range MultirangeRel8.Internal.Type.ReadShowReadShow fromReadShowRel8.Internal.ExprExprRel8.Internal.Expr.OpaleyeunsafeCastExprunsafeCoerceExpr unsafeLiteralunsafePrimExprRel8.Internal.Expr.SerializelitExprRel8.Internal.Expr.ArraylistOf nonEmptyOfRel8.Internal.Type.Semigroup DBSemigroup<>.Rel8.Internal.Type.MonoidDBMonoid memptyExprRel8.Internal.Expr.Bool&&.and_boolExprcaseExprcoalescenot_or_||.Rel8.Internal.Expr.Null isNonNullisNull liftOpNullmapNullnullnullifyunsafeUnnullifyRel8.Internal.Expr.FunctionbinaryOperatorfunctionrawBinaryOperator rawFunction ArgumentsRel8.Internal.Table.AlternativeAltTable<|>:AlternativeTable emptyTableRel8.Internal.Schema.NameNameSelectsRel8.Internal.Table.NamenamesFromLabelsnamesFromLabelsWithRel8.Internal.Table.Opaleye castTable"Rel8.Internal.Statement.OnConflictConflict OnConstraintOnIndexIndex predicate OnConflictAbort DoNothingDoUpdateUpsertconflictset updateWhereRel8.Internal.Expr.SubscriptunsafeSubscriptunsafeSubscriptsRel8.Internal.Table.Serializelit SerializableToExprsRel8.Internal.Expr.SequencenextvalRel8.Internal.Expr.Range multirangerangeRel8.Internal.Expr.NonEmpty head1Expr index1Expr last1Expr length1ExprRel8.Internal.Expr.ListheadExpr indexExprlastExpr lengthExprRel8.Internal.Expr.Text!~!~*++.ascii bitLengthbtrim charLengthchrconvert convertFrom convertToilikeinitcapleftlengthlengthEncodinglikelowerlpadltrimmd5 octetLengthpgClientEncoding quoteIdent quoteLiteral quoteNullable regexpReplaceregexpSplitToArrayrepeatreplacereverserightrpadrtrim splitPartstrpossubstr translateupper~*~.Rel8.Internal.Expr.Default unsafeDefaultRel8.Internal.Table.Boolboolcase_nullableRel8.Internal.Expr.Orderascdesc nullsFirst nullsLastRel8.Internal.Expr.Ord<.<=.<=?.>=.>=?>? greatestExpr leastExprRel8.Internal.Expr.Eq/=./=?==.==?in_Rel8.Internal.Table.Eq/=:==:EqTableeqTable $dmeqTableRel8.Internal.Table.Ord<:<=:>:>=:greatestleastOrdTableordTable $dmordTableRel8.Internal.Table.OrderascTable descTableRel8.Internal.QueryQueryRel8.Internal.Query.Setexcept exceptAll intersect intersectAllunionunionAllRel8.Internal.Query.ValuesvaluesRel8.Internal.Query.OrderorderByRel8.Internal.Query.MaterializeRel8.Internal.Query.Looploop loopDistinctRel8.Internal.Query.LimitlimitoffsetRel8.Internal.Query.RebindrebindRel8.Internal.Query.Function queryFunctionRel8.Internal.Query.Filterwhere_Rel8.Internal.Query.EvaluateevaluateRel8.Internal.Query.EacheachRel8.Internal.Query.ExistsabsentexistspresentwithwithBywithout withoutByRel8.Internal.Query.Distinctdistinct distinctOn distinctOnByRel8.Internal.Aggregate toAggregator toAggregator1 Aggregator Aggregator' Aggregator1 Rel8.Internal.Aggregate.FunctionaggregateFunctionrawAggregateFunctionRel8.Internal.Aggregate.RangerangeAggRel8.Internal.Type.StringDBStringRel8.Internal.Type.SumDBSumRel8.Internal.Expr.AggregateandandOnavgavgOncount countDistinctcountDistinctOncountOn countStar countWhere countWhereOndistinctAggregatehypotheticalCumeDisthypotheticalDenseRankhypotheticalPercentRankhypotheticalRank listAggExpr listAggExprOn listCatExpr listCatExprOnmaxmaxOnminminOnmodemodeOnnonEmptyAggExprnonEmptyAggExprOnnonEmptyCatExprnonEmptyCatExprOnororOn percentilepercentileContinuouspercentileContinuousOn percentileOn stringAggsumsumOnsumWhereRel8.Internal.Table.Maybe$?fromMaybeTable isJustTableisNothingTable maybeTablenameMaybeTable MaybeTableRel8.Internal.Table.NullisNonNullTable isNullTable nameNullTable nullTable nullableTable nullifyTable toMaybeTable toNullTableunsafeUnnullifyTable NullTableRel8.Internal.Table.NonEmpty$+head1index1last1length1nameNonEmptyTable nonEmptyTable NonEmptyTableRel8.Internal.Column.NonEmpty HNonEmptyRel8.Internal.Table.List$*headindexlast listTable nameListTable ListTableRel8.Internal.Table.Aggregate filterWheregroupBy groupByOnlistAgg listAggOnlistCat listCatOn nonEmptyAgg nonEmptyAggOn nonEmptyCat nonEmptyCatOnorderAggregateByRel8.Internal.Column.ListHListRel8.Internal.Query.NullcatNull catNullTableRel8.Internal.Column.NullHNull#Rel8.Internal.Table.Aggregate.MaybeaggregateJustTableaggregateJustTable1aggregateMaybeTablefilterWhereOptionaloptionalAggregateRel8.Internal.Table.TheseaggregateHereTableaggregateHereTable1aggregateThatTableaggregateThatTable1aggregateThereTableaggregateThereTable1aggregateTheseTableaggregateThisTableaggregateThisTable1aggregateThoseTableaggregateThoseTable1alignMaybeTable hasHereTable hasThereTable isThatTable isThisTable isThoseTable justHereTablejustThereTablenameTheseTable thatTable theseTable thisTable thoseTable TheseTableRel8.Internal.Column.TheseHTheseRel8.Internal.Query.Maybe catMaybeTableoptionaltraverseMaybeTableRel8.Internal.Query.Aggregate aggregate aggregate1 countRowsRel8.Internal.Statement StatementRel8.Internal.Statement.SelectselectRel8.Internal.Query.SQL showQueryRel8.Internal.Statement.Runrunrun1runMayberunN runVectorrun_!Rel8.Internal.Statement.Returning Returning NoReturningRel8.Internal.Statement.UpdateupdateUpdatefrom returningtarget Rel8.Internal.Statement.PreparedpreparedRel8.Internal.Statement.InsertinsertInsertinto onConflictrowsRel8.Internal.Statement.ViewcreateOrReplaceView createViewRel8.Internal.Statement.DeletedeleteDelete deleteWhereusingRel8.Internal.Statement.SQL showDelete showInsertshowPreparedStatement showStatement showUpdateRel8.Internal.Query.ListcatList catListTable catNonEmptycatNonEmptyTablemanymanyExprsomesomeExprRel8.Internal.Column.MaybeHMaybeRel8.Internal.Table.EitheraggregateEitherTableaggregateLeftTableaggregateLeftTable1aggregateRightTableaggregateRightTable1 eitherTable isLeftTable isRightTable leftTablenameEitherTable rightTable EitherTableRel8.Internal.Query.EitherbitraverseEitherTable keepLeftTablekeepRightTableRel8.Internal.Column.EitherHEitherRel8.Internal.Query.ThesealignBybitraverseTheseTable keepHereTable keepThatTablekeepThereTable keepThisTablekeepThoseTable loseHereTable loseThatTableloseThereTable loseThisTableloseThoseTableRel8.Internal.Generic.Rel8able KRel8ableRel8ableRel8.Internal.Table.HKDbuildHKD constructHKDdeconstructHKDnameHKDBuildHKD ConstructHKDDeconstructHKDHKDHKDableNameHKDRel8.Internal.Column.LiftLiftRel8.Internal.Table.ADTbuildADT constructADTdeconstructADTnameADTADTADTableBuildADT ConstructADTDeconstructADTNameADTRel8.Internal.Type.Compositecompose decompose Composite DBCompositecompositeFieldscompositeTypeNameRel8.Internal.Column.ADTHADTRel8.Internal.WindoworderPartitionByover partitionBy PartitionWindowRel8.Internal.Query.WindowwindowRel8.Internal.Expr.WindowcumeDist cumulative denseRankntile percentRankrank rowNumberRel8.Internal.Table.Window currentRow firstValue firstValueOnlaglagOn lastValue lastValueOnleadleadOnnthValue nthValueOnRel8.Internal.Query.Indexedindexedelemelem1notElemnotElem1ceilingdivModfloor fromIntegralquotRem realToFracroundtruncateaddDaysaddTimedaydaysdiffDaysdiffTimefromDayhourhoursminuteminutesmonthmonthsnow scaleIntervalsecondseconds subtractDays subtractTimetoDaytodayweekweeksyearyearsderiveRel8ablederiveRel8ables$fShowParsedDatatype$fShowParsedField difference fromQuery leftAlign leftAlignWith liftQuerylookuporder rightAlignrightAlignWith similaritythroughtoQuery Tabulation$fAltTableTabulation$fAlternativeTableTabulation$fApplicativeTabulation$fFunctorTabulation$fApplyTabulation$fBifunctorTabulation$fBindTabulation$fBiprojectableTabulation$fContravariantPredicate$fMonadTabulation$fMonoidPredicate$fSemigroupPredicate$fMonoidTabulation$fSemigroupTabulation$fProjectableTabulationtime-1.15-inplaceData.Time.Calendar.DaysDayParsedDatatype ParsedField foldr1TreegenerateColumnsEgenerateColumnsPgenerateConstructorEgenerateConstructorP prettyFail ghc-internalGHC.Internal.Control.Monad.FailfailresolveColumnFGHC.Internal.Base ApplicativepureliftA2peekRel8.Internal.Query.OpaleyeunsafePeekQuery