h$̒      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred./2 Safe-Inferred/>~None./> None  Safe-Inferred'(/? "  Safe-Inferred '(/>? i  Safe-Inferred'(/?  None< rel8An ordering expression for a(. Primitive orderings are defined with  and , and you can combine Order via its various instances.A common pattern is to use 1 to combine multiple orderings in sequence, and >$< (from ) to select individual columns.None 3 Safe-Inferred'(-. k Safe-Inferred'(-/>?Frel8The Sql type class describes both null and not null database values, constrained by a specific class.For example, if you see  Sql DBEq a<, this means any database type that supports equality, and a can either be exactly an a, or it could also be Maybe a.rel8 Nullable a means that rel8 is able to check if the type a is a type that can take null values or not.rel8Homonullable a b means that both a and b can be null, or neither a or b can be null.rel8 nullify a means a cannot take null as a value.  Safe-Inferred5< rel8The schema for a table. This is used to specify the name and schema that a table belongs to (the FROM part of a SQL query), along with the schema of the columns within this table.For each selectable table in your database, you should provide a  TableSchema. in order to interact with the table via Rel8. rel8The name of the table. rel8*The schema that this table belongs to. If #, whatever is on the connection's  search_path will be used. rel8The columns of the table. Typically you would use a a higher-kinded data type here, parameterized by the  functor. None%'(rel8TypeInformation describes how to encode and decode a Haskell type to and from database queries. The typeName is the name of the type in the database, which is used to accurately type literals. rel89How to encode a single Haskell value as a SQL expression.rel83How to deserialize a single result back to Haskell.rel8The name of the SQL type.rel8Simultaneously map over how a type is both encoded and decoded, while retaining the name of the type. This operation is useful if you want to essentially newtype another .The mapping is required to be total. If you have a partial mapping, see .rel8Apply a parser to .This can be used if the data stored in the database should only be subset of a given . The parser is applied when deserializing rows returned - the encoder assumes that the input data is already in the appropriate form.None %&'(None>rel8Haskell types that can be represented as expressions in a database. There should be an instance of DBType6 for all column types in your database schema (e.g., int,  timestamptz, etc).Rel8 comes with stock instances for most default types in PostgreSQL, so you should only need to derive instances of this class for custom database types, such as types defined in PostgreSQL extensions, or custom domain types.rel8Corresponds to jsonbrel8Corresponds to uuidrel8Corresponds to bytearel8Corresponds to bytearel8Corresponds to citextrel8Corresponds to citextrel8Corresponds to textrel8Corresponds to textrel8Corresponds to intervalrel8Corresponds to timerel8Corresponds to  timestamprel8Corresponds to daterel8Corresponds to  timestamptzrel8Corresponds to numericrel8Corresponds to float8rel8Corresponds to float4rel8Corresponds to int8rel8Corresponds to int4rel8Corresponds to int2rel8Corresponds to charrel8Corresponds to boolNone>?rel8Database types that can be compared for equality in queries. If a type is an instance of , it means we can compare expressions for equality using the SQL = operator.None'(/? None-/>LNone%-/>NoneNone/ None/!None/9>?jrel8A HTable is a functor-indexed/higher-kinded data type that is representable (/), constrainable (), and specified ().This is an internal concept for Rel8, and you should not need to define instances yourself or specify this constraint. "None'(+-./0> #None%'(-/8:<>Nrel8 Transform a  by allowing it to be null.$None#$'(-/8:<>%None '(/&None %'(/ 'None />B(None/>)None./>? *None+/>  +None#$%'(-/8:<>? t,None/ -None/ .None%?!Nrel89Cast an expression to a different type. Corresponds to a CAST() function call. /None%?"0rel8%Produce an expression from a literal.Note that you can usually use 0, but litExpr6 can solve problems of inference in polymorphic code.1None >?$rel8 This type class exists to allow  to have arbitrary arity. It's mostly an implementation detail, and typical uses of & shouldn't need this to be specified.rel8-Construct an n-ary function that produces an ' that when called runs a SQL function.rel8:Construct a function call for functions with no arguments. rel8Construct an expression by applying an infix binary operator to two operands. 2None'(( !rel8The SQL false literal."rel8The SQL true literal.#rel8The SQL AND operator.$rel8The SQL OR operator.%rel8The SQL NOT operator.&rel8Fold AND" over a collection of expressions.'rel8Fold OR" over a collection of expressions.(rel8&Eliminate a boolean-valued expression.Corresponds to 34.)rel8A multi-way ifthen&else statement. The first argument to caseExpr is a list of alternatives. The first alternative that is of the form  (true, x) will be returned. If no such alternative is found, a fallback expression is returned.Corresponds to a CASE expression in SQL.*rel8 Convert a Expr (Maybe Bool) to a  Expr Bool by treating Nothing as False(. This can be useful when combined with 5, which expects a Bool, and produces expressions that optimize better than general case analysis. !"#$%&'()*#3$26None/?++rel8!Lift an expression that can't be null to a type that might be null. This is an identity operation in terms of any generated query, and just modifies the query's type.rel8Like , but to eliminate null.,rel8Like 78 , but for null.-rel8Like 79 , but for null..rel8Lift an operation on non-null$ values to an operation on possibly null values. When given null,  mapNull f returns null. This is like  for ./rel8Lift a binary operation on non-null; expressions to an equivalent binary operator on possibly null4 expressions. If either of the final arguments are null,  liftOpNull returns null. This is like liftA2 for .0rel8Corresponds to SQL null. +,-./0:None&'(?01rel8&Compare two expressions for equality. This corresponds to the SQL IS NOT DISTINCT FROM operator, and will equate null values as true. This differs from = which would return null#. This operator matches Haskell's - operator. For an operator identical to SQL =, see 3.2rel82Test if two expressions are different (not equal).This corresponds to the SQL IS DISTINCT FROM operator, and will return false when comparing two null$ values. This differs from ordinary = which would return null'. This operator is closer to Haskell's - operator. For an operator identical to SQL =, see 4.3rel8Test if two expressions are equal. This operator is usually the best choice when forming join conditions, as PostgreSQL has a much harder time optimizing a join that has multiple  conditions.This corresponds to the SQL =+ operator, though it will always return a .4rel8'Test if two expressions are different. This corresponds to the SQL <>+ operator, though it will always return a .5rel8 Like the SQL IN8 operator, but implemented by folding over a list with 1 and $.1234514243444;None/?1 <None16rel8Like =, but works for jsonb columns.678>None2U9rel8A deriving-via helper type for column types that store a Haskell value using a JSON encoding described by aeson's  and  type classes.9:;?None />?4L<rel8-The class of database types that support the / operator.=rel8-The class of database types that support the / operator.>rel8The class of database types that can be coerced to from integral expressions. This is a Rel8 concept, and allows us to provide .?rel8-The class of database types that support the +, *, - operators, and the abs, negate, sign functions.<=>?@None>?5@rel8-The class of database types that support the min aggregation function.Arel8-The class of database types that support the max aggregation function.Brel8-The class of database types that support the <, <=, > and >= operators.@ABANone/>?8>Grel8A deriving-via helper type for column types that store an "enum" type (in Haskell terms, a sum type where all constructors are nullary) using a Postgres enum type.Note that this should map to a specific type in your database's schema (explicitly created with CREATE TYPE ... AS ENUM). Use D to specify the name of this Postgres type and the names of the individual values. If left unspecified, the names of the values of the Postgres enum are assumed to match exactly exactly the names of the constructors of the Haskell type (up to and including case sensitivity).CDEFGHBNone&8Irel8A deriving-via helper type for column types that store a Haskell value using a Haskell's  and  type classes.IJKCNone +/>?9Lrel8 The class of s that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the  Semigroup class.Mrel8An associative operation.LMM6DNone  />?:Nrel8 The class of s that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the  class.NOENone>?;%Prel8)The class of data types that support the  string_agg() aggregation function.PFNone />?;Qrel8-The class of database types that support the sum() aggregation function.QGNone/:<=; HNone/8:<< INone/8:<<=JNone/8:<?< LNone/>?< MNone#%/9>?@Rrel8Tables are one of the foundational elements of Rel8, and describe data types that have a finite number of columns. Each of these columns contains data under a shared context, and contexts describe how to interpret the metadata about a column to a particular Haskell type. In Rel8, we have contexts for expressions (the N context), aggregations (the O context), insert values (the P contex), among others.?In typical usage of Rel8 you don't need to derive instances of R. yourself, as anything that's an instance of Q is always a R.Srel8The 1 functor that describes the schema of this table.Trel8=The common context that all columns use as an interpretation.rel8!Any context is trivially a table.rel8Any  is also a R. RSTUVWXYRNone />@ZSNone'(./2<>A2rel8Typed SQL expressions.TNone%?AaUNone#%/9>?C"[rel8 Serializable; witnesses the one-to-one correspondence between the type sql/, which contains SQL expressions, and the type haskell:, which contains the Haskell decoding of rows containing sql SQL expressions.`rel8Use lit2 to turn literal Haskell values into expressions. lit is capable of lifting single Exprs to full tables.[\]^_`VNone#&+/9>?Earel8 The class of Rs that can be compared for equality. Equality on tables is defined by equality of all columns all columns, so this class means "all columns in a R have an instance of ".brel8 Compare two Rs for equality. This corresponds to comparing all columns inside each table for equality, and combining all comparisons with AND.crel8 Test if two Rs are different. This corresponds to comparing all columns inside each table for inequality, and combining all comparisons with OR.abcb4c4WNone&?Gpdrel8%An if-then-else expression on tables. bool x y p returns x if p is False, and returns y if p is True.erel8Produce a table expression from a list of alternatives. Returns the first table where the  Expr Bool expression is True>. If no alternatives are true, the given default is returned.frel8Like , but to eliminate null.defXNone?Irgrel8Like  Alternative in Haskell, some R)s form a monoid on applicative functors.hrel8The identity of j.irel8Like Alt in Haskell. This class is purely a Rel8 concept, and allows you to take a choice between two tables. See also g.For example, using j on Y allows you to combine two tables and to return the first one that is a "just" MaybeTable.jrel8#An associative binary operation on Rs.ghijj3ZNone'(./2<>?KHkrel8 Selects a b means that a is a schema (i.e., a R of l s) for the  columns in b.lrel8A Name is the name of a column, as it would be defined in a table's schema definition. You can construct names by using the OverloadedStrings extension and writing string literals. This is typically done when providing a  TableSchema value.kl[None %&?K~mn\None'(M.orel8INSERT, UPDATE and DELETE all support returning either the number of rows affected, or the actual rows modified. q allows you to project out of these returned rows, which can be useful if you want to log exactly which rows were deleted, or to view a generated id (for example, if using a column with an autoincrementing counter as a default value).opqNoneRrrel8Corresponds to  date(now()).srel8Corresponds to calling the date function with a given time.trel8Corresponds to x::timestamptz.urel8:Move forward a given number of days from a particular day.vrel8=Find the number of days between two days. Corresponds to the - operator.wrel82Subtract a given number of days from a particular . xrel8Corresponds to now().yrel8Add a time interval to a point in time, yielding a new point in time.zrel8$Find the duration between two times.{rel8Subtract a time interval from a point in time, yielding a new point in time.}rel8An interval of one second.~rel83Create a literal interval from a number of seconds.rel8An interval of one minute.rel83Create a literal interval from a number of minutes.rel8An interval of one hour.rel81Create a literal interval from a number of hours.rel8An interval of one day.rel80Create a literal interval from a number of days.rel8An interval of one week.rel81Create a literal interval from a number of weeks.rel8An interval of one month.rel82Create a literal interval from a number of months.rel8An interval of one year.rel81Create a literal interval from a number of years.rstuvwxyz{|}~rstuvwxyz{|}~None/\)rel8-The PostgreSQL string concatenation operator.rel8*Matches regular expression, case sensitiveCorresponds to the ~. operator.rel8,Matches regular expression, case insensitiveCorresponds to the ~* operator.rel81Does not match regular expression, case sensitiveCorresponds to the !~ operator.rel83Does not match regular expression, case insensitiveCorresponds to the !~* operator.rel8Corresponds to the  bit_length function.rel8Corresponds to the  char_length function.rel8Corresponds to the lower function.rel8Corresponds to the  octet_length function.rel8Corresponds to the upper function.rel8Corresponds to the ascii function.rel8Corresponds to the btrim function.rel8Corresponds to the chr function.rel8Corresponds to the convert function.rel8Corresponds to the  convert_from function.rel8Corresponds to the  convert_to function.rel8Corresponds to the decode function.rel8Corresponds to the encode function.rel8Corresponds to the initcap function.rel8Corresponds to the left function.rel8Corresponds to the length function.rel8Corresponds to the length function.rel8Corresponds to the lpad function.rel8Corresponds to the ltrim function.rel8Corresponds to the md5 function.rel8Corresponds to the pg_client_encoding() expression.rel8Corresponds to the  quote_ident function.rel8Corresponds to the  quote_literal function.rel8Corresponds to the quote_nullable function.rel8Corresponds to the regexp_replace function.rel8Corresponds to the regexp_split_to_array function.rel8Corresponds to the repeat function.rel8Corresponds to the replace function.rel8Corresponds to the reverse function.rel8Corresponds to the right function.rel8Corresponds to the rpad function.rel8Corresponds to the rtrim function.rel8Corresponds to the  split_part function.rel8Corresponds to the strpos function.rel8Corresponds to the substr function.rel8Corresponds to the  translate function.))62222]None/^rel8!Sort a column in ascending order.rel8"Sort a column in descending order.rel8Transform an ordering so that null+ values appear first. This corresponds to  NULLS FIRST in SQL.rel8Transform an ordering so that null+ values appear first. This corresponds to  NULLS LAST in SQL.^None'(/?e. rel8Corresponds to the SQL <+ operator. Note that this differs from SQL < as null3 will sort below any other value. For a version of < that exactly matches SQL, see .rel8Corresponds to the SQL <=+ operator. Note that this differs from SQL <= as null3 will sort below any other value. For a version of <= that exactly matches SQL, see .rel8Corresponds to the SQL >+ operator. Note that this differs from SQL > as null3 will sort below any other value. For a version of > that exactly matches SQL, see .rel8Corresponds to the SQL >=+ operator. Note that this differs from SQL > as null3 will sort below any other value. For a version of >= that exactly matches SQL, see .rel8Corresponds to the SQL < operator. Returns null if either arguments are null.rel8Corresponds to the SQL <= operator. Returns null if either arguments are null.rel8Corresponds to the SQL > operator. Returns null if either arguments are null.rel8Corresponds to the SQL >= operator. Returns null if either arguments are null.rel8Given two expressions, return the expression that sorts less than the other.Corresponds to the SQL least() function.rel8Given two expressions, return the expression that sorts greater than the other.Corresponds to the SQL  greatest() function. 44444444_None#&/9>?irel8 The class of Tables that can be ordered. Ordering on tables is defined by their lexicographic ordering of all columns, so this class means "all columns in a Table have an instance of B".rel8 Test if one Table sorts before another. Corresponds to comparing all columns with .rel8 Test if one Table sorts before, or is equal to, another. Corresponds to comparing all columns with .rel8 Test if one Table sorts after another. Corresponds to comparing all columns with .rel8 Test if one Table sorts after another. Corresponds to comparing all columns with .rel8 Given two Table0s, return the table that sorts before the other.rel8 Given two Table/s, return the table that sorts after the other.4444`None/jrel8 Construct an  for a Table by sorting all columns into ascending orders (any nullable columns will be sorted with  NULLS FIRST).rel8 Construct an  for a Table by sorting all columns into descending orders (any nullable columns will be sorted with  NULLS LAST).None?nMrel8Cast > types to ? types. For example, this can be useful if you need to turn an  Expr Int32 into an  Expr Double.rel8Cast ? types to =3 types. For example, his can be useful to convert  Expr Float to  Expr Double.rel8Round a = to a >, by rounding to the nearest larger integer.Corresponds to the  ceiling() function.rel8.Perform integral division. Corresponds to the div() function.rel8Corresponds to the mod() function.rel8Round a  DFractional to a >. by rounding to the nearest smaller integer. Corresponds to the floor() function.rel8Round a = to a >% by rounding to the nearest integer.Corresponds to the round() function.rel8Round a = to a >2 by rounding to the nearest integer towards zero.aNone%'(./<=>?prel8Aggregates a b means that the columns in a are all  s for the columns in b.rel8An  Aggregate a describes how to aggregate Table s of type a. You can unpack an  Aggregate back to a by running it with b. As  Aggregate is almost an  functor - but there is no  operation. This means  is an instance of Apply, and you can combine  Aggregate s using the  . combinator.cNone %'(/0>p dNone%/0>?q1eNone#%'(./>?s rel8 Inserts a b means that the columns in a. are compatible for inserting with the table b.rel8The constituent parts of a SQL INSERT statement.rel8Which table to insert into.rel8The rows to insert.rel8What to do if the inserted rows conflict with data already in the table.rel8)What information to return on completion.rel8 OnConflict allows you to add an  ON CONFLICT clause to an INSERT statement.rel8 ON CONFLICT ABORTrel8 ON CONFLICT DO NOTHINGfNone #%&+?trel8Transform a table by adding CAST to all columns. This is most useful for finalising a SELECT or RETURNING statement, guaranteed that the output matches what is encoded in each columns TypeInformation.gNone #%'(v rel8The constituent parts of a DELETE statement.rel8Which table to delete from.rel8+Which rows should be selected for deletion.rel8What to return from the DELETE statement.rel8Run a DELETE statement.hNone?wrel8Construct a query that returns the given input list of rows. This is like folding a list of  statements under i, but uses the SQL VALUES expression for efficiency.jNone?zrel8Combine the results of two queries of the same type, collapsing duplicates.  union a b" is the same as the SQL statement  x UNION b.rel8Combine the results of two queries of the same type, retaining duplicates.  unionAll a b" is the same as the SQL statement  x UNION ALL b.rel8>Find the intersection of two queries, collapsing duplicates. intersect a b" is the same as the SQL statement  x INTERSECT b.rel8=Find the intersection of two queries, retaining duplicates. intersectAll a b" is the same as the SQL statement x INTERSECT ALL b.rel8:Find the difference of two queries, collapsing duplicates  except a b# is the same as the SQL statement  x INTERSECT b.rel8;Find the difference of two queries, retaining duplicates.  exceptAll a b# is the same as the SQL statement x EXCEPT ALL b.kNone<={rel8The Query monad allows you to compose a SELECT7 query. This monad has semantics similar to the list ([]) monad.rel8h =  [].rel8j = .lNone|rel8#Order the rows returned by a query.mNone}7rel8limit n select at most n rows from a query. limit n is equivalent to the SQL LIMIT n.rel8offset n drops the first n rows from a query. offset n is equivalent to the SQL OFFSET n.nNone~rel8 filter f x will be a zero-row query when f x is False, and will return x unchanged when f x is True. This is similar to op, but as the predicate is separate from the argument, it is easy to use in a pipeline of  transformations.rel8-Drop any rows that don't match a predicate.  where_ expr is equivalent to the SQL  WHERE expr.qNonerel8 Filter a  that might return null to a  without any nulls.Corresponds to 7r.sNone&? rel8Convert a query to a  containing the query as a SELECT statement.tNone?rel8Given a   and ,  createView runs a  CREATE VIEW statement that will save the given query as a view. This can be useful if you want to share Rel8 queries with other applications.uNonerel8Run a SELECT query, returning all rows.vNone?rel8?Select each row from a table definition. This is equivalent to  FROM table.wNone}rel8=Select all distinct rows from a query, removing duplicates.  distinct q% is equivalent to the SQL statement SELECT DISTINCT q.rel8Select all distinct rows from a query, where rows are equivalent according to a projection. If multiple rows have the same projection, it is unspecified which row will be returned. If this matters, use .rel8Select all distinct rows from a query, where rows are equivalent according to a projection. If there are multiple rows with the same projection, the first row according to the specified  will be returned.xNone%&?rel8toInsert converts a Table of Expr s into a Table that can be used with y. This will override any columns that have default values to use exactly what is given. If you want to use default values, you can either override the result of toInsert , or use .rel8toInsertDefaults converts a Table of Expr s into a Table that can be used with y. Any columns that have a default value will override whatever is in the input expression. One example where this is useful is for any table that has a special id column, which has a default value to draw a new value from a sequence. If we use , we can provide a dummy value that will be replaced with a call to DEFAULT.zNone%/5<>?O rel8 MaybeTable t is the table t, but as the result of an outer join. If the outer join fails to match any rows, this is essentialy Nothing7, and if the outer join does match rows, this is like Just. Unfortunately, SQL makes it impossible to distinguish whether or not an outer join matched any rows based generally on the row contents - if you were to join a row entirely of nulls, you can't distinguish if you matched an all null row, or if the match failed. For this reason  MaybeTable contains an extra field - a "nullTag" - to track whether or not the outer join produced any rows.rel8 Check if a  MaybeTable is absent of any row. Like 78.rel8 Check if a  MaybeTable contains a row. Like 79.rel8Perform case analysis on a . Like .rel8The null table. Like .rel8Lift any table into . Like . Note you can also use .rel8%Project a single expression out of a +. You can think of this operator like the 2 operator, but it also has the ability to return null.rel8Has the same behavior as the Monad instance for Maybe . See also: {.rel8Has the same behavior as the  Applicative instance for Maybe . See also: |. 4}None#$%/5<>?~None+rel8Convert a query that might return zero rows to a query that always returns at least one row.!To speak in more concrete terms,  is most useful to write  LEFT JOINs.rel8 Filter out /s, returning only the tables that are not-null.3This operation can be used to "undo" the effect of ), which operationally is like turning a  LEFT JOIN back into a full JOIN*. You can think of this as analogous to 7r.rel8bindMaybeTable f x! is similar to the monadic bind (>>=) operation. It allows you to "extend" an optional query with another query. If either the input or output are , then the result is .This is similar to , followed by a join on the resulting  MaybeTables.rel8Extend an optional query with another query. This is useful if you want to step through multiple  LEFT JOINs. Note that traverseMaybeTable takes a  a -> Query b function, which means you also have the ability to "expand" one row into multiple rows. If the  a -> Query b function returns no rows, then the resulting query will also have no rows. However, regardless of the given  a -> Query b function, if the input is noTable", you will always get exactly one noTable back.None/rel8+Checks if a query returns at least one row.rel8 Query b yields no rows.rel8Like without$, but with a custom membership test.None%'(`rel8The constituent parts of an UPDATE statement.rel8Which table to update.rel8 How to update each selected row.rel8 Which rows to select for update.rel8What to return from the UPDATE statement.rel8Run an UPDATE statement.None%/5<>? None?)rel8Corresponds to a FULL OUTER JOIN between two queries. None?cNone%'(rel8Run an INSERT statement None'(/ None'(/>?INone%>?+rel8A  NonEmptyTable) value contains one or more instances of a. You construct  NonEmptyTables with  or  nonEmptyAgg.None%>?rel8A  ListTable* value contains zero or more instances of a. You construct  ListTables with  or .None/?rel88Count the occurances of a single column. Corresponds to COUNT(a)rel8Count the number of distinct occurances of a single column. Corresponds to COUNT(DISTINCT a)rel8Corresponds to COUNT(*).rel85A count of the number of times a given expression is true.rel8Corresponds to bool_and.rel8Corresponds to bool_or.rel8Produce an aggregation for Expr a using the max function.rel8Produce an aggregation for Expr a using the max function.rel8Corresponds to sum. Note that in SQL, sum% is type changing - for example the sum of integer returns a bigint. Rel8 doesn't support this, and will add explicit cast back to the original input type. This can lead to overflows, and if you anticipate very large sums, you should upcast your input.rel89Take the sum of all expressions that satisfy a predicate.rel8Corresponds to  string_agg().rel8$Aggregate a value by grouping by it.rel8%Collect expressions values as a list.rel8/Collect expressions values as a non-empty list.None %&?^rel8Group equal tables together. This works by aggregating each column in the given table with .rel8Aggregate rows into a single row containing an array of all aggregated rows. This can be used to associate multiple rows with a single row, without changing the over cardinality of the query. This allows you to essentially return a tree-like structure from queries.For example, if we have a table of orders and each orders contains multiple items, we could aggregate the table of orders, pairing each order with its items: ordersWithItems :: Query (Order Expr, ListTable (Item Expr)) ordersWithItems = do order <- each orderSchema items  -aggregate $ listAgg <$. itemsFromOrder order return (order, items) rel8Like 6, but the result is guaranteed to be a non-empty list.None?rel8/Apply an aggregation to all rows returned by a .rel8Count the number of rows returned by a query. Note that this is different from  countStar-, as even if the given query yields no rows,  countRows will return 0.None 5  ( ProjectId) (Project ) projectsById =  projectId Note: the nature of primary keys means that each key will be mapped to a singleton value in this case. Tabulation by other unique key projectsByName :: Project  ->  ( Text) (Project ) projectsByName =  projectName Tabulation by foreign key (tabulate a child table by parent key)% revisionsByProjectId :: Revision  ->  ( ProjectId) (Revision ) revisionsByProjectId =  revisionProjectId rel8Like  but takes a monadic  function instead of a pure one. This means you can filter rows while calculating the key, which is useful in conjunction with .rel8 Analgous to .rel8Map a  over the input side of a . rel8Map a  over the output side of a .rel8Note that because  is a MultiMap, the  returned by - can and often does contain multiple results.rel8Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:alignalign.If  makes an  INNER JOIN, then  makes a FULL OUTER JOIN.rel8Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:alignWith alignWith.See  and .rel8If  makes an  INNER JOIN, then  makes a  LEFT JOIN. This means it will return at least one row for every row in the left , even if there is no corresponding row in the right (hence the Y).Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:rpadZiprpadZip.rel8See  and .Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:rpadZipWith rpadZipWith.rel8Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:zipzip.There are multiple correct ways of understanding what this does.You can think of it as  ( (,)) . That is,  intersect the two (s by matching their keys together (with /), and combine their values (remembering that  is a MultiMap so that the values are keys) by getting their cartesian product.You can think of it as performing a cross product of the underlying s of the given  s and filtering the results for match ing keys.3You can think of it as a natural join in SQL terms.The size of the resulting  will be \sum_{k} min(n_k, m_k) & in terms of the number of keys, but \sum_{k} n_k \times m_k# in terms of the number of values.rel8Analagous to  https://hackage.haskell.org/package/semialign/docs/Data-Semialign.html#v:zipWithzipWith.See .rel8% returns all the entries in the left / that have a corresponding entry in the right 8. This corresponds to a semijoin in relational algebra.This differs from  const x y when the right  y, contains an entry with multiple rows. For  , the entries in the resulting  will contain the same number of rows as their respective entries in the left  x:. With `zipWith const x y`, each entry would contain the product7 of the number of rows of their respective entries in x and y.See .rel8% returns all the entries in the left  that don't exist in the right 9. This corresponds to an antijoin in relational algebra.See .rel8 orders the values of a  within each key.:In general this is meaningless, but if used together with  or , the resulting lists will be ordered according to ordering given to .rel8Turns the given  from a "multimap" into a "map". If there is more than one value at a particular key, only the first one is kept. "First" is in general undefined, but ' can be used to make it deterministic.11None%'(?rel8 Aggregate a  into a . If the supplied query returns 0 rows, this function will produce a , that returns one row containing the empty  ListTable. If the supplied Query does return rows, many& will return exactly one row, with a  ListTable collecting all returned rows.many is analogous to  from Control.Applicative.rel8 Aggregate a  into a . If the supplied query returns 0 rows, this function will produce a - that is empty - that is, will produce zero  NonEmptyTables. If the supplied Query does return rows, some% will return exactly one row, with a  NonEmptyTable collecting all returned rows.some is analogous to  from Control.Applicative.rel8 A version of # specialised to single expressions.rel8 A version of # specialised to single expressions.None '(/?JNone /?None '(/?None /?None /?#None/orel8The Column type family should be used to indicate which fields of your data types are single columns in queries. This type family has special support when a query is executed, allowing you to use a single data type for both query data and rows decoded to Haskell.None /?None/9>?Òrel8,This type class allows you to define custom Tables using higher-kinded data types. Higher-kinded data types are data types of the pattern: data MyType f = MyType { field1 :: Column f T1 OR HK1 f , field2 :: Column f T2 OR HK2 f , ... , fieldN :: Column f Tn OR HKn f } where Tn is any Haskell type, and HKn is any higher-kinded type.That is, higher-kinded data are records where all fields in the record are all either of the type  Column f T (for any T)), or are themselves higher-kinded data: Nested data Nested f = Nested { nested1 :: MyType f , nested2 :: MyType f } The Rel8able type class is used to give us a special mapping operation that lets us change the type parameter f.  Supplying Rel8able instancesThis type class should be derived generically for all table types in your project. To do this, enable the  DeriveAnyType and  DeriveGeneric language extensions: {-# LANGUAGE DeriveAnyClass, DeriveGeneric #-} data MyType f = MyType { fieldA :: Column f T } deriving ( GHC.Generics.Generic, Rel8able ) None+/>None%&-/>?CNone/>?ęNone/>?None/>`None%&'(+/?rel8A deriving-via helper type for column types that store a Haskell product type in a single Postgres column using a Postgres composite type.Note that this must map to a specific extant type in your database's schema (created with  CREATE TYPE). Use  to specify the name of this Postgres type and the names of the individual fields (for projecting with ).None /ZNone /ǑNone#Ǹ  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRTSUWVXYZ[\]^_`abcdefghijklmnopq9:;678IJKGHDEFCLMNO?>=<RTSUWVXYijghabc`de lmn0+f,-./*"!%#&$'12345()B kA@QP[opqZ]^_\None#/28:<=>7SN    k!&'./11112222222222666666:::::<<<>=>=>????@@@AAAAAABBBCCDDEFMMMMMMMMRUUUUUU0VVVW4WWXXXXZZ[[\\\]]]]^^^^^^^^^^_``aaOePePeeeeeeegggggghjijjjjjlmmnn5qstuvwwwxxzYzzzzzzzz}}}}}}}}}}}}}}~~~{~|ybQ                       Q  !!!!!!!!!""""""""""######$$$$%%%%%&&&&&&&&'''''((((((()))))))))***********+++++,-...........//6766666;;;;;;;GGGGGGGGGHHHHHHIIIIJJJJJKKKKKKKKKKLLLLLLLLLLMMMMMMMSNSSTUUVZZZ[[[_______aaaaaaaaOaaacccccccccddddddddddddddeeeeeeffffffffkkkssuzzzYzz}}}#rel8-0.1.0.0-6WGnAxdrAzWHA7eZIsUDZMRel8Rel8.Expr.TimeRel8.Expr.Text Rel8.Expr.Num Rel8.TabulateRel8.FCFRel8.Generic.MapRel8.Generic.RecordRel8.Generic.ReifyRel8.Kind.AlgebraRel8.Kind.LabelsRel8.Kind.Necessity Rel8.OrderascdescRel8.Query.OpaleyeRel8.Schema.DictRel8.Schema.NullRel8.Schema.TableRel8.ColumnSchema ColumnSchemaRel8.Type.InformationDBTypeRel8.Type.Array Rel8.Type Rel8.Type.EqRel8.Schema.SpecRel8.Schema.Spec.ConstrainType Rel8.Schema.Spec.ConstrainDBTypeRel8.Schema.KindRel8.Schema.HTable.ProductRel8.Schema.ContextRel8.Schema.HTableRel8.Schema.HTable.MapTableRel8.Schema.HTable.NullifyRel8.Schema.HTable.LabelRel8.Schema.HTable.IdentityRel8.Schema.ResultRel8.Schema.Context.LabelRel8.Schema.ReifyRel8.Generic.Table.Record Rel8.Generic.Construction.RecordRel8.Schema.HTable.VectorizeRel8.Schema.HTable.NonEmptyRel8.Schema.HTable.ListRel8.Expr.OpaleyeRel8.Expr.SerializelitRel8.Expr.FunctionRel8.Expr.Bool Data.Boolboolwhere_Rel8.Expr.Null Data.Maybe isNothingisJust Rel8.Expr.EqRel8.Expr.ArrayRel8.Type.JSONBEncoded JSONEncodedRel8.Type.JSONEncoded Rel8.Type.Num Rel8.Type.OrdRel8.Type.EnumRel8.Type.ReadShowRel8.Type.SemigroupRel8.Type.MonoidRel8.Type.String Rel8.Type.Sum Rel8.Type.TagRel8.Schema.HTable.TheseRel8.Schema.HTable.MaybeRel8.Schema.HTable.EitherRel8.Generic.Table.ADTRel8.Generic.Table Rel8.TableExpr AggregateInsertRel8ableRel8.Table.Recontextualize Rel8.ExprRel8.Table.UndefinedRel8.Table.Serialize Rel8.Table.EqRel8.Table.BoolRel8.Table.Alternative MaybeTableRel8.Schema.NameRel8.Table.NameRel8.Statement.ReturningRel8.Expr.Order Rel8.Expr.OrdRel8.Table.OrdRel8.Table.OrderRel8.Aggregate aggregateRel8.Table.TagRel8.Schema.Context.NullifyRel8.Schema.InsertRel8.Table.OpaleyeRel8.Statement.DeleteRel8.Query.ValuesunionRel8.Query.Set Rel8.QueryRel8.Query.OrderRel8.Query.LimitRel8.Query.Filter Control.MonadguardRel8.Query.Null catMaybesRel8.Query.SQLRel8.Statement.ViewRel8.Statement.SelectRel8.Query.EachRel8.Query.DistinctRel8.Table.InsertinsertRel8.Table.MaybebindMaybeTabletraverseMaybeTableRel8.Table.TheseRel8.Query.Maybe nothingTableRel8.Query.ExistsRel8.Statement.UpdateRel8.Table.EitherRel8.Query.TheseRel8.Query.EitherRel8.Statement.InsertRel8.Kind.ContextRel8.Table.UnreifyRel8.Table.NonEmptysomeRel8.Table.ListmanylistAggRel8.Expr.AggregateRel8.Table.AggregateRel8.Query.Aggregate Rel8.ExtracatNullsData.Map.StrictfromListintersectionWith==:withwithoutRel8.Query.ListControl.ApplicativeRel8.Column.TheseRel8.Column.NonEmptyRel8.Column.MaybeRel8.Column.ListRel8.Column.Field Rel8.ColumnRel8.Column.EitherRel8.Generic.Rel8ableRel8.Generic.Construction.ADTRel8.Generic.ConstructionRel8.Table.HKDRel8.Table.ADTRel8.Table.Rel8ableRel8.Type.CompositeRel8.Column.LiftRel8.Column.ADTRel8.Generic.Rel8able.Test NecessityOptionalRequiredOrderQuerySqlNullableNotNull TableSchemanameschemacolumnsTypeInformationencodedecodetypeNamemapTypeInformationparseTypeInformationtypeInformationDBEqHTableResult LabelableunsafeCastExprlitExprFunctionfunctionnullaryFunctionbinaryOperatorfalsetrue&&.||.not_and_or_boolExprcaseExprcoalescenullifyisNull isNonNullmapNull liftOpNullnull==./=.==?/=?in_ JSONBEncodedfromJSONBEncodedfromJSONEncoded DBFloating DBFractional DBIntegralDBNumDBMinDBMaxDBOrdEnumableDBEnum enumValue enumTypeNameEnumReadShow fromReadShow DBSemigroup<>.DBMonoid memptyExprDBStringDBSumTableColumnsContextUnreify toColumns fromColumnsreifyunreifyRecontextualize Serializable FromExprsToExprs fromResulttoResultEqTable/=:case_nullableAlternativeTable emptyTableAltTable<|>:SelectsNamenamesFromLabelsnamesFromLabelsWith ReturningNumberOfRowsAffected ProjectiontodaytoDayfromDayaddDaysdiffDays subtractDaysnowaddTimediffTime subtractTime scaleIntervalsecondsecondsminuteminuteshourhoursdaydaysweekweeksmonthmonthsyearyears++.~.~*!~!~* bitLength charLengthlower octetLengthupperasciibtrimchrconvert convertFrom convertToinitcapleftlengthlengthEncodinglpadltrimmd5pgClientEncoding quoteIdent quoteLiteral quoteNullable regexpReplaceregexpSplitToArrayrepeatreplacereverserightrpadrtrim splitPartstrpossubstr translate nullsFirst nullsLast<.<=.>.>=.?>=? leastExpr greatestExprOrdTableascTable descTable fromIntegral realToFracceilingdivmodfloorroundtruncate Aggregates$sel:into:Insert$sel:rows:Insert$sel:onConflict:Insert$sel:returning:Insert OnConflictAbort DoNothingDelete$sel:from:Delete$sel:deleteWhere:Delete$sel:returning:DeletedeletevaluesunionAll intersect intersectAllexcept exceptAllorderBylimitoffsetfiltercatNull showQuery createViewselecteachdistinct distinctOn distinctOnBytoInserttoInsertDefaultsisNothingTable isJustTable maybeTable justTable$?insertMaybeTablenameMaybeTable TheseTable isThisTable isThatTable isThoseTable hasHereTable hasThereTable justHereTablejustThereTable thisTable thatTable thoseTable theseTableinsertTheseTablenameTheseTableoptional catMaybeTableexists whereExistswhereNotExistswithBy withoutByUpdatetargetset updateWhere returningupdate EitherTable isLeftTable isRightTable eitherTable leftTable rightTableinsertEitherTablenameEitherTablealignBy keepHereTable loseHereTablekeepThereTableloseThereTable keepThisTable loseThisTable keepThatTable loseThatTablekeepThoseTableloseThoseTablebindTheseTablebitraverseTheseTable keepLeftTablekeepRightTablebindEitherTablebitraverseEitherTable NonEmptyTable nonEmptyTableinsertNonEmptyTablenameNonEmptyTable ListTable listTableinsertListTable nameListTablecount countDistinct countStar countWhereandormaxminsumsumWhere stringAgg listAggExprnonEmptyAggExprgroupBy nonEmptyAgg countRows Tabulation runTabulation liftQuerytabulate tabulateA fromQueryindexedifilterprebindpostbindlookupalign alignWith leftAlign leftAlignWithzipzipWith similarity differenceaggregateTabulationorderTabulationdistinctTabulationoptionalTabulationmanyTabulationsomeTabulation$fMonoidTabulation$fSemigroupTabulation$fAlternativeTableTabulation$fAltTableTabulation$fMonadTabulation$fBindTabulation$fApplicativeTabulation$fApplyTabulation$fFunctorTabulationmanyExprsomeExpr catListTablecatNonEmptyTablecatList catNonEmptyHThese HNonEmptyHMaybeHListFieldDefaultColumnHEither KRel8able AggregateHKDNameHKDDeconstructHKD ConstructHKD InsertHKDBuildHKDHKDableHKDTunHKDTHKDfromHKDtoHKDbuildHKD insertHKD constructHKDdeconstructHKDnameHKD aggregateHKD AggregateADTNameADTDeconstructADT ConstructADT InsertADTBuildADTADTableADTfromADTtoADTbuildADT insertADT constructADTdeconstructADTnameADT aggregateADT DBCompositecompositeFieldscompositeTypeName Compositecompose decomposeLiftHADTComposeEvalExp GMappablegmapgunmapGMapRecordunrecord GRecordablegrecord gunrecordGRecordARep KnownAlgebra algebraSingSAlgebraSProductSSumAlgebraProductSum KnownLabels labelsSingSLabelsSNilSConsLabels renderLabelsKnownNecessity necessitySing SNecessity SOptional SRequiredbaseGHC.Base<>Data.Functor.Contravariant Contravariant toOrderExprs fromOpaleye toOpaleye mapOpaleyezipOpaleyeWithDict HomonullableNullityNullNullify Unnullify GHC.MaybeNothingarraylistTypeInformationnonEmptyTypeInformationencodeArrayElementextractArrayElement $fDBTypeValue $fDBTypeUUID$fDBTypeByteString$fDBTypeByteString0 $fDBTypeCI $fDBTypeCI0 $fDBTypeText $fDBTypeText0$fDBTypeCalendarDiffTime$fDBTypeTimeOfDay$fDBTypeLocalTime $fDBTypeDay$fDBTypeUTCTime$fDBTypeScientific$fDBTypeDouble $fDBTypeFloat $fDBTypeInt64 $fDBTypeInt32 $fDBTypeInt16 $fDBTypeChar $fDBTypeBool KnownSpecspecSingSSpeclabels necessityinfonullitySpec ConstrainTypeConstrainDBType dbTypeNullity dbTypeDict nullifier unnullifierHContextHProductInterpretationCol htabulatehfieldhdictshspecs htraverseHFieldHConstrainTablehmap htabulateAMapSpecmapInfoHMapTableField Precompose precomposed HMapTable unHMapTableHNullifyhnullshnullify hunnullifyLabelHLabelhlabelhunlabel HIdentityHType unHIdentityRunRrelabel vectorizer unvectorizer HLabelablehlabeler hunlabelerlabeler unlabelerReifyNotReify UnwrapReifyhreifyhunreifynotReifyGToExprs gfromResult gtoResultGTablegtable gfromColumns gtoColumnsGContextGColumnsGConstructable gconstruct gdeconstruct Representable gtabulategindexGFields GConstruct GConstructor ToColumns FromColumns HVectorize hvectorize hunvectorizehappendhemptyHNonEmptyTable HListTablecastExpr scastExprsunsafeCastExpr unsafeLiteral fromPrimExpr toPrimExpr mapPrimExprzipPrimExprsWithtraversePrimExprtoColumn fromColumnslitExpr sparseValue nullableExprmaybefmapMaybeunsafeUnnullify nullableOfsnull unsafeMapNullunsafeLiftOpNullghc-prim GHC.Classes== GHC.TypesTrueBoolsappendsappend1semptyslistOf snonEmptyOflistOf nonEmptyOf#aeson-1.5.6.0-FdxJbuJtnG6NRgiKV0UflData.Aeson.Types.ToJSONToJSONData.Aeson.Types.FromJSONFromJSONGHC.RealGHC.ReadReadGHC.ShowShowMonoidTagMaybeTagIsJust EitherTagIsLeftIsRightisLeftisRight HTheseTablehhereTaghhere hthereTaghthere HMaybeTablehtaghjust HEitherTablehlefthright GToExprsADTgfromResultADT gtoResultADT GTableADT' GTableADT gtableADTgfromColumnsADT gtoColumnsADT GColumnsADT' GColumnsADTGAlgebra GGContext GGColumns GGToExprsGGTable ggfromColumns ggtoColumnsggtable ggfromResult ggtoResult$fTablecontextCol$fTablecontextt CongruentTUnreifyTContextTColumnsTTableEunE undefinedTToExprsparseeqTableNunN showExprs showLabels showNames time-1.9.3Data.Time.Calendar.DaysDay<:<<=:<=>:>>=:>=leastgreatestordTable ApplicativepureAunA Aggregator operationordering distinction foldInputs mapInputsunsafeMakeAggregateTaggable aggregatorexpr fromAggregatefromExprfromName HNullifiable HConstrainTag hencodeTag hdecodeTag hnullifier hunnullifier Nullifiable ConstrainTag encodeTag decodeTagrunTagunnullInsertsI $sel:unI:ICreateValue castTable binaryspec distinctspectable tableFields unpackspec valuesspecreturn$fAlternativeTableQuery$fAltTableQueryString sqlForQuerysqlForQueryWithNamesselectWithNamesJust$$fMonadMaybeTable$fApplicativeMaybeTabletagjustherethereinQuery Reifiable contextSingSContextSReify SAggregateSExprSInsertSNameSResult sReifiable sLabelableUnreifiabilityUResult Unreifiable Unreifiesunreifiability groupByExpr slistAggExprsnonEmptyAggExprhgroupByliftA2AHThese AHNonEmptyAHMaybeAHListAFieldTColumnAHEitherTUnreifyContextGRepgunreifygreify GMakeableADTgmakeADTGConstructableADTgdeconstructADT gconstructADT gbuildADT gunbuildADTRepresentableFields gftabulategfindex GBuildADTRepresentableConstructors gctabulategcindex GConstructors GConstructADTGConstructorADT GGAggregateGGName GGDeconstruct GGConstructGGConstructableGGInsertGGBuild GGBuildableggbuildgginsert ggconstruct ggdeconstructggname ggaggregateHKDRepConstructableHKD BuildableHKDADTRepConstructableADT BuildableADTALiftunALiftAHADT TableProduct$sel:foos:TableProduct$sel:sum:TableProduct$sel:list:TableProductTableSum TableSumC TableSumA TableSumB NonRecordHKDTest$sel:s3Object:HKDTest$sel:hkdSum:HKDTestHKDSumHKDSumCHKDSumAHKDSumBS3Object$sel:bucketName:S3Object$sel:objectKey:S3Object TableNest$sel:foo:TableNest$sel:bars:TableNest TableNonEmpty$sel:foo:TableNonEmpty$sel:bars:TableNonEmpty TableList$sel:foo:TableList$sel:bars:TableList TableThese$sel:foo:TableThese$sel:bars:TableThese TableEither$sel:foo:TableEither$sel:bars:TableEither TableMaybe$sel:foo:TableMaybe$sel:bars:TableMaybe TablePair$sel:foo:TablePair$sel:bars:TablePair TableTest$sel:foo:TableTest$sel:bar:TableTest