ѽe      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""#### $ $ $ $ $$$$$$$$$$$$$$$$$$% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2&3&4&5&6&7&8&9&:&;&<&=&>'?'@'A'B'C'D'E'F'G'H'I'J'K'L(M(N(O(P(Q(R(S(T(U)V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~*****,SafeSafe $Data type for SQL DELETE statements. $Data type for SQL UPDATE statements.Expressions in SQL statements.3Aggregate functions separate from normal functions.)!A valid SQL name for a parameter.(  !"#$%&'()*+,-./(  !"#$%&'()*+,-./(,-./*+)&'(#$% !"      !"#$%&'()*+,-./Safe6789:;<=>?@A 6789:;<=>?@A 6;<=?789>:A@6789:;<=>?@ASafeBCDEBCDEBCDEBCDEB8C8D8E8Saferepresents a default valueused for hacking in custom SQLComposite Type Query#Cast an expression to a given type. ARRAY[..]eFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~eFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkxom~lnpqrstuvwyz{|}eklmnopqrstuvwxyz{|}~abcdefghijRSTUVWXYZ[\]^_`PQMNOJKLFGHIFGHIJKLMNOPQRSTUVWXYZ[\]^_`a bcdefghijk lmnopqrstuvwxyz{|}~SafeA relation-valued expression666 SafeSafe[ SafedTurn a string into a quoted string. Quote characters and any escaping are handled by this function. NoneQuote a string and escape characters that need escaping We use Postgres "escape strings", i.e. strings prefixed with E, to ensure that escaping with backslash is valid.$Escape characters that need escaping4Quote binary literals using Postgresql's hex format.     Table to update=Conditions which must all be true for a row to be updated.Update the data with this.;Criteria which must all be true for a row to be deleted.                NoneJA relation-valued expressionbFFor ensuring that we have at least one column in a SELECT or RETURNINGI !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdI !"%#$&'()*+,-./0123456789:;<@A?B=>CDFEGIHJKLMNOPQRSTUVWXYZ[\]^_`abcdIGHIJKLMNDEF;<=>?@ABC6789:2345-./01)*+,"#$%&'( !OPQRSTUVWXYZ[\]^_`abcd  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd Nonenopqrstuvwxyz{|}~nopqrstuvwxyz{|}~nopqrstuvwxyz{|}~nopqrstuvwxyz{|}~ NoneOT.A helpful monad for writing columns in the ASTA  a b s t encodes how an s$ contains an updatable sequence of a inside it. Each a& in the sequence can be updated to a b (and the s changes to a t" to reflect this change of type). is just like a  Traversal from the lens package. ' has a different order of arguments to  Traversal* because it typically needs to be made a  (and indeed ) in s and t9. It is unclear at this point whether we want the same  Traversal? laws to hold or not. Our use cases may be much more general.$Replaces the targeted occurences of a in s with b (changing the s to a t, in the process). This can be done via an  action. is just like traverse from the lens package.  used to be called packmap.#Modify the targeted occurrences of a in s with b (changing the s to a t in the process). is just like over from the lens pacakge.3Make a fresh name for an input value (the variable primExpr type is typically actually a 1) based on the supplied function and the unique  that is used as part of our QueryArr.XAdd the fresh name and the input value it refers to to the list in the state parameter.As  but ignores the primExpr? when making the fresh column name and just uses the supplied  and . Safe>A dummy typeclass whose instances support integral operations.Only used within a ,, to indicate that it can take null values.Treat a  as though it were of a different type. If such a treatment is not valid then Postgres may fail with an error at SQL run time.7Cast a column to any other type. Implements Postgres's :: or CAST( ... AS ... )G operations. This is safe for some conversions, such as uuid to text.SafeNoneTK/KJNoneA NULL of any typeTRUE if the value of the column is NULL, FALSE otherwise.If the Column (Nullable a) is NULL then return the Column b otherwise map the underlying Column a using the provided function.The Opaleye equivalent of +,.If the Column (Nullable a)# is NULL then return the provided Column a! otherwise return the underlying Column a.The Opaleye equivalent of +-.@Treat a column as though it were nullable. This is always safe.The Opaleye equivalent of +..If the argument is +/M return NULL otherwise return the provided value coerced to a nullable type.  None9:;<=5 provides a convenient typeclass wrapper around the  creation functions in Opaleye.PGTypesH. Besides convenience it doesn't provide any additional functionality.#It can be used with functions like $0z to insert custom Haskell types into the database. The following is an example of a function for inserting custom types.  customInsert :: (  / haskells columns ) => Connection -> 12Y columns columns' -> haskells -> IO Int64 customInsert conn table haskells = $0 conn table $  haskells YIn order to use this function with your custom types, you need to define an instance of   for your custom types.#      !"#$%#%$#"!      !      !"#$%None9;<='An & columns columns'1 allows you to extract and modify a sequence of s inside a value of type columns.For example, the Default instance of type & (Column a, Column b) (Column a, Column b). allows you to manipulate or extract the two  s inside a (Column a, Column b). The Default instance of type $Foo (Column a) (Column b) (Column c)4 will allow you to manipulate or extract the three 6s contained therein (for a user-defined product type Foo, assuming the makeAdaptorAndInstance splice from Data.Profunctor.Product.TH has been run).You can create &s by hand using ( and the ,  and  SumProfunctor operations. However, in practice users should almost never need to create or manipulate them. Typically they will be created automatically by the  instance.(Target the single  inside a )Modify all the targeted s*Extract all the targeted s &'()*+,-./0&'()* &'()*0/.-,+ &'()*+,-./0None1aA Postgres query, i.e. some functionality that can run via SQL and produce a collection of rows.Query a! is analogous to a Haskell value [a].2 QueryArr a b$ is analogous to a Haskell function a -> [b].123456789:;<=>? 123456789231456789?>=<;:123456789:;<=>?3None1212None@+Add a commented label to the generated SQL.@@@@None:TAWhen  is returned it means that the Query returns zero rows.Example type specialization: AshowSqlForPostgres :: Query (Column a, Column b) -> Maybe String  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: SshowSqlForPostgres :: Query (Foo (Column a) (Column b) (Column c)) -> Maybe String ELFor internal use only. Do not use. Will be deprecated in a future release.ABCDEABCDEABCDEABCDENone:<= FGHIJKLMNOPFGHIJK HFGIJKPONML FGHIJKLMNOPNone9;<= QRSTUVWXYZ[QRSTUV STUQRV[ZYXW QRSTUVWXYZ[None:\\ implements Postgres's VALUESM construct and allows you to create a query that consists of the given rows.Example type specialization: ?values :: [(Column a, Column b)] -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: equeryTable :: [Foo (Column a) (Column b) (Column c)] -> Query (Foo (Column a) (Column b) (Column c)) \]\]\]\]None9:;<= ^_`abcdefg^_`a ^_`gfaedcb ^_`abcdefgNone9:;<=h Left query Right queryCondition on which to join Left joini Left query Right queryCondition on which to join Right joinj Left query Right queryCondition on which to joinFull outer joinklmhijklmhijklmhijklmNone9:;<=nA n pgType  haskellType' represents the default way to turn a pgType8 result from the database into a Haskell value of type  haskellType.Creating an instance of nO for your own types is necessary for retrieving those types from the database.=You should use one of the three methods below for writing a n instance. If you already have a  instance for your  haskellType, use t=. (This is how most of the built-in instances are defined.)If you don't have a  instance, use 4* if possible. See the documentation for 4 for an example./If you have a more complicated case, but not a  instance, write a  for your type and use u. You can also add a  instance using this.qHave we actually requested any columns? If we asked for zero columns then the SQL generator will have to put a dummy 0 into the SELECT statement, since we can't select zero columns. In that case we have to make sure we read a single Int.rA r pgType  haskellType/ encodes how to turn a value of Postgres type pgType into a value of Haskell type  haskellType. For example a value of type r   encodes how to turn a * result from the database into a Haskell ./nopqrstuvwxyz{|}~nopqrstuvwxyz{|}~/rspqtuvwnoxyz{|}~,nopqrstuvwxyz{|}~None:runQuery's use of the  typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using runQuery.Example type specialization: runQuery :: Query (Column 5 , Column 6&) -> IO [(Column Int, Column String)]  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: runQuery :: Query (Foo (Column 5 ) (Column 6 ) (Column 7C) -> IO [(Foo (Column Int) (Column String) (Column Bool)] HOpaleye types are converted to Haskell types based on instances of the 8 typeclass. runQueryFoldY streams the results of a query incrementally and consumes the results with a left fold. This fold is notk strict. The stream consumer is responsible for forcing the evaluation of its result to avoid space leaks.Use X to make an instance to allow you to run queries on your own datatypes. For example: newtype Foo = Foo Int instance QueryRunnerColumnDefault Foo Foo where queryRunnerColumnDefault = queryRunnerColumn (9 :: Column Foo -> Column PGInt4) Foo queryRunnerColumnDefault QFor internal use only. Do not use. Will be deprecated in a subsequent release. noprtu prnotuNoneAn E represents an expression to order on and a sort direction. Multiple s can be composed with :; or (<>) from  Data.Monoid0. If two rows are equal according to the first  , the second is used, and so on.   None?Typeclass for Postgres types which support ordering operations.Order the rows of a 1 according to the Order. import Data.Monoid (<>) -- Order by the first column ascending. When first columns are equal -- order by second column descending. example :: 1 ( ,   ) -> 1 ( ,   ) example =  ( fst <>  snd) QSpecify an ascending ordering by the given expression. (Any NULLs appear last)SSpecify an descending ordering by the given expression. (Any NULLs appear first)RSpecify an ascending ordering by the given expression. (Any NULLs appear first)RSpecify an descending ordering by the given expression. (Any NULLs appear last)JLimit the results of the given query to the given maximum number of items.ZOffset the results of the given query by the given amount, skipping that many result rows.  NoneLAn $ takes a collection of rows of type aC, groups them, and transforms each group into a single row of type b(. This corresponds to aggregators using GROUP BY in SQL.An  corresponds closely to a <= from the foldl package. Whereas an  a b takes each group of type a to a single row of type b, a <= a b takes a list of a" and returns a single row of type b.,Order the values within each aggregation in | using the given ordering. This is only relevant for aggregations that depend on the order they get their elements, like '> and '?.You can either apply it to an aggregation of multiple columns, in which case it will apply to all aggregation functions in there, or you can apply it to a single column, and then compose the aggregations afterwards. Examples: x :: Aggregator (Column a, Column b) (Column (PGArray a), Column (PGArray a)) x = (,) <$> orderAggregate (asc snd) (lmap fst arrayAggGrouped) <*> orderAggregate (desc snd) (lmap fst arrayAggGrouped)This will generate: ]SELECT array_agg(a ORDER BY b ASC), array_agg(a ORDER BY b DESC) FROM (SELECT a, b FROM ...) Or: x :: Aggregator (Column a, Column b) (Column (PGArray a), Column (PGArray b)) x = orderAggregate (asc snd) $ p2 (arrayAggGrouped, arrayAggGrouped)This will generate: \SELECT array_agg(a ORDER BY b ASC), array_agg(b ORDER BY b ASC) FROM (SELECT a, b FROM ...)   !None9;<="None:OTUses the default schema name ("public"). Schema name ("public"< by default in PostgreSQL), table name, table properties.  #None:Example type specialization: IqueryTable :: Table w (Column a, Column b) -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: mqueryTable :: Table w (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c))   $None: Insert rows into a table CInsert rows into a table and return a function of the inserted rowsrunInsertManyReturning's use of the  typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using runInsertManyReturning. Update rows in a table @Update rows in a table and return a function of the updated rowsrunUpdateReturning's use of the  typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using runInsertReturning. Delete rows from a table0You probably don't need this, but can just use q instead. You only need it if you want to run an INSERT RETURNING statement but need to be explicit about the  QueryRunner.0You probably don't need this, but can just use  q instead. You only need it if you want to run an UPDATE RETURNING statement but need to be explicit about the  QueryRunner.0You probably don't need this, but can just use  q instead. You only need it if you want to run an UPDATE RETURNING statement but need to be explicit about the  QueryRunner.#Returns the number of rows inserted2This will be deprecated in a future release. Use   instead.runInsertReturning's use of the  typeclass means that the compiler will have trouble inferring types. It is strongly recommended that you provide full type signatures when using runInsertReturning.3This will be deprecated in a future release. Use   instead.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release.NFor internal use only. Do not use. Will be removed in a subsequent release. Table to insert intoRows to insertNumber of rows inserted Table to insert intoRows to insert Function f to apply to the inserted rowsReturned rows after f has been applied Table to update'Update function to apply to chosen rowsPredicate function f" to choose which rows to update.   will update rows for which f returns TRUE% and leave unchanged rows for which f returns FALSE.The number of updated rows Table to update'Update function to apply to chosen rowsPredicate function f# to choose which rows to update.   will update rows for which f returns TRUE% and leave unchanged rows for which f returns FALSE.Functon g to apply to the updated rowsReturned rows after g has been applied Table to delete rows fromPredicate function f" to choose which rows to delete.   will delete rows for which f returns TRUE% and leave unchanged rows for which f returns FALSE.The number of deleted rows&          &     %None9:;<=AT& Boolean and !"#$%&'()*+,-./01  !"#$%&'()*+%&#$'1 !"(0)*+/.-, !"#$%&'()*+,-./01%4&3&None:<=3PThe same as unionAll, except that it additionally removes any duplicate rows.5TThe same as intersectAll, except that it additionally removes any duplicate rows.7QThe same as exceptAll, except that it additionally removes any duplicate rows. 23456789:;<= 23456789:;<= 23456789:;<= 23456789:;<='None >Given a 1 producing rows of type a and an  accepting rows of type a3, apply the aggregator to the results of the query.MIf you simply want to count the number of rows in a query you might find the K function more convenient.3By design there is no aggregation function of type 0Aggregator b b' -> QueryArr a b -> QueryArr a b'\. Such a function would allow violation of SQL's scoping rules and lead to invalid queries.9Please note that when aggregating an empty query with no GROUP BYf clause, Opaleye's behaviour differs from Postgres's behaviour. Postgres returns a single row whereas Opaleye returns zero rows. (Opaleye's behaviour is consistent with the meaning of aggregating over groups of rows and Postgres's behaviour is inconsistent. When a query has zero rows it has zero groups, and thus zero rows in the result of an aggregation.)?,Order the values within each aggregation in { using the given ordering. This is only relevant for aggregations that depend on the order they get their elements, like I and J.Note that this orders all aggregations with the same ordering. If you need different orderings for different aggregations, use .@2Group the aggregation by equality on the input to @.ASum all rows in a group.B-Count the number of non-null rows in a group.C+Count the number of rows in a group. This  is named  countStar after SQL's COUNT(*) aggregation function.DAverage of a groupEMaximum of a groupFMaximum of a groupK>Count the number of rows in a query. This is different from > BP because it always returns exactly one row, even when the input query is empty.>?@ABCDEFGHIJK>?@ABCDEFGHIJK>?@ABCDEFGHIJK>?@ABCDEFGHIJK(None<= LMNOPQRSTLMN NLMTSRQPOLMNOPQRST)None:URemove duplicate rows from the 1.Example type specialization: Edistinct :: Query (Column a, Column b) -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: idistinct :: Query (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c)) By design there is no distinct function of type QueryArr a b -> QueryArr a b]. Such a function would allow violation of SQL's scoping rules and lead to invalid queries.UNUUNU*None:V>Class of Postgres types that can be used to index json values.KWarning: making additional instances of this class can lead to broken code!W3Class of Postgres types that represent json values.;Used to overload functions and operators that work on both  and .KWarning: making additional instances of this class can lead to broken code!XRestrict query results to a particular condition. Corresponds to the guard method of the MonadPlus class. You would typically use X if you want to use  notation. Y Filter a 2B to only those rows where the given condition holds. This is the 2 equivalent of  from the Prelude. You would typically use Y) if you want to use a "point free" style.\LA polymorphic equality operator that works for all types that you have run makeAdaptorAndInstance on. This may be unified with Z in a future version.]NA polymorphic inequality operator that works for all types that you have run makeAdaptorAndInstance on. This may be unified with Z in a future version.f Boolean orh Concatenate  i To lowercasej To uppercasek Postgres LIKE operatorm.True when any element of the container is truenn' is designed to be used in prefix form.n  validProducts product checks whether product is a valid product. n  validProductsB is a function which checks whether a product is a valid product.oSTrue if the first argument occurs amongst the rows of the second, false otherwise.+This operation is equivalent to Postgres's INA operator but, for expediency, is currently implemented using a  LEFT JOIN<. Please file a bug if this causes any issues in practice.tGet JSON object field by key.uGet JSON object field as text.v"Get JSON object at specified path.w*Get JSON object at specified path as text.x;Does the left JSON value contain within it the right value?y8Is the left JSON value contained within the right value?z8Does the key/element string exist within the JSON value?{*Do any of these key/element strings exist?|*Do all of these key/element strings exist?}Cast a PGInt4 to a PGFloat8-VWXYZ[\]^_`abcdefghijklmnopqrst key or indexu key or indexvpathwpathxyz{|}~)&VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}.XYZ[\]^_`abcdefghijklmnopqrsWV~tuvwxyz{|}&-VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Z4[4\4]4^4_4`4a4f2t8u8v8w8x4y4z4{4|41None&12@ABCDE\]hijklmnoprtu     &23456789:;<=>?@ABCDEFGHIJKNUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}@ABCDEFGHHIIJJKLMNOPQRSTUVWXYZ[\\]^_`abcdeffgghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0 1 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M M   N O              P Q R   S T   U V W X X Y Z [ \ ] ^ _ ` _ a b 2  c d e f g h i j   k l m 5 n o p   q r ) s t u v w x y z { | } ~      x r                       9l657      !"##$%&'()*+,-../0123456789:;<=>?@@ABCDEFGHIJJKLMNOPQRSTUUVWXYZ[\]^_`ab8cddeefghijklmnopqrstuvwxyz{|}~4  ]^             !!!!!!!!!!!!!!!!!!""""""""""""2"2"""""""""""""""""""####$$$$$$$$$0$$$$$$$$$$$$$%%%%%%%%%%%%%%%% % % % & &&&&&&&&&&&'''\''''''' '!'>'?'"(#(#($(%(&('((()(*)+*,*-*&*.**/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*VWXYZ[\]^_`ab`ac]de`a/fghfgi`jk`lmn&opaleye-0.5.1.1-JOhXYbWHZBZBJUz7lg3yEWOpaleye.Internal.TagOpaleye.Internal.HaskellDB.Sql$Opaleye.Internal.HaskellDB.Sql.PrintOpaleye.Internal.Helpers$Opaleye.Internal.HaskellDB.PrimQueryOpaleye.Internal.PrimQueryOpaleye.Internal.LabelOpaleye.Internal.Optimize'Opaleye.Internal.HaskellDB.Sql.Generate&Opaleye.Internal.HaskellDB.Sql.DefaultOpaleye.Internal.SqlOpaleye.Internal.PrintOpaleye.Internal.PackMapOpaleye.Internal.ColumnOpaleye.Internal.PGTypesOpaleye.PGTypesOpaleye.ColumnOpaleye.ConstantOpaleye.Internal.UnpackspecOpaleye.Internal.QueryArr Opaleye.Label Opaleye.SqlOpaleye.Internal.BinaryOpaleye.Internal.ValuesOpaleye.ValuesOpaleye.Internal.Join Opaleye.JoinOpaleye.Internal.RunQueryOpaleye.RunQueryOpaleye.Internal.Order Opaleye.OrderOpaleye.Internal.AggregateOpaleye.Internal.TableMakerOpaleye.Internal.Table Opaleye.TableOpaleye.ManipulationOpaleye.Internal.OperatorsOpaleye.BinaryOpaleye.AggregateOpaleye.Internal.DistinctOpaleye.DistinctOpaleye.Operators Data.Maybemaybe fromMaybeJustNothing runInsertOpaleyeTableOpaleye.QueryArrqueryRunnerColumnPGInt4PGTextPGBoolQueryRunnerColumnDefaultunsafeCoerceColumn Data.Monoidmappend Control.FoldlFoldarrayAgg stringAggTag UnsafeTagstartnext unsafeUnTagtagWith $fReadTag $fShowTag SqlInsert SqlDelete SqlUpdateSqlExpr ColumnSqlExprCompositeSqlExpr BinSqlExpr PrefixSqlExprPostfixSqlExpr FunSqlExprAggrFunSqlExpr ConstSqlExpr CaseSqlExpr ListSqlExpr ParamSqlExprPlaceHolderSqlExpr ParensSqlExpr CastSqlExprDefaultSqlExpr ArraySqlExprSqlOrdersqlOrderDirection sqlOrderNullsSqlOrderDirectionSqlAscSqlDesc SqlOrderNulls SqlNullsFirst SqlNullsLastSqlName SqlColumnSqlTablesqlTableSchemaName sqlTableName$fShowSqlTable$fShowSqlColumn$fShowSqlOrderNulls$fShowSqlOrderDirection$fShowSqlOrder $fShowSqlExpr deliteralppWhere ppGroupBy ppOrderByppAsppUpdateppDeleteppInsertppTable ppSqlExprcommaHcommaV.:.:..::.::.OrderOporderDirection orderNullsOrderDirectionOpAscOpDesc OrderNulls NullsFirst NullsLast OrderExprAggrOp AggrCountAggrSumAggrAvgAggrMinAggrMax AggrStdDev AggrStdDevPAggrVarAggrVarP AggrBoolOr AggrBoolAndAggrArrAggrStringAggr AggrOtherUnOpOpNotOpIsNull OpIsNotNullOpLengthOpAbsOpNegateOpLowerOpUpper UnOpOtherBinOp:==:<:<=:>:>=:<>OpAndOpOrOpLikeOpInOpOther:||:+:-:*:/OpMod:~:&:|:^:= OpAtTimeZone:->:->>:#>:#>>:@>:<@:?:?|:?&LiteralNullLit DefaultLitBoolLit StringLit ByteStringLit IntegerLit DoubleLitOtherLitPrimExprAttrExprBaseTableAttrExpr CompositeExprBinExprUnExprAggrExpr ConstExprCaseExprListExpr ParamExprFunExprCastExprDefaultInsertExpr ArrayExprSymbolAssocSchemeName Attribute TableName $fReadSymbol $fShowSymbol $fReadLiteral $fShowLiteral $fShowBinOp $fReadBinOp $fShowUnOp $fReadUnOp$fShowOrderNulls$fReadOrderNulls$fShowOrderDirection$fReadOrderDirection $fShowOrderOp $fReadOrderOp$fShowOrderExpr$fReadOrderExpr$fReadPrimExpr$fShowPrimExpr $fShowAggrOp $fReadAggrOpPrimQueryFold' PrimQueryFoldunitempty baseTableproduct aggregateorderlimitjoinvaluesbinarylabelrelExpr PrimQuery PrimQuery'UnitEmpty BaseTableProduct AggregateOrderLimitJoinValuesBinaryLabelRelExprTableIdentifier tiSchemaName tiTableNameJoinTypeLeftJoin RightJoinFullJoinExcept ExceptAllUnionUnionAll Intersect IntersectAllLimitOpOffsetOp LimitOffsetOp tiToSqlTableprimQueryFoldDefault foldPrimQuerytimesrestrictisUnit $fShowLimitOp$fShowJoinType$fShowTableIdentifier$fShowPrimQuery'label'optimize removeUnit mergeProduct removeEmpty SqlGenerator sqlUpdate sqlDelete sqlInsertsqlExpr sqlLiteralsqlQuoteUnOpTypeUnOpFun UnOpPrefix UnOpPostfixmkSqlGeneratordefaultSqlGenerator toSqlOrder toSqlColumn toSqlAssocdefaultSqlUpdatedefaultSqlInsertdefaultSqlDeletedefaultSqlExpr showBinOpsqlUnOp showAggrOpdefaultSqlLiteraldefaultSqlQuotequoteescapebinQuote ReturninglLabellSelectbOpbSelect1bSelect2vAttrsvValues jJoinTypejTablesjCondFromattrstablescriteriagroupByorderByoffset SelectAttrsStarSelect SelectFrom SelectJoin SelectValues SelectBinary SelectLabelsqlQueryGeneratorsqlaggrExprlimit_joinTypebinOp newSelect sqlBinding ensureColumnsensureColumnsGen$fShowSelectAttrs $fShowValues $fShowLabel $fShowSelect $fShowBinary $fShowJoin $fShowFrom TableAliasppSql ppSelectFrom ppSelectJoinppSelectValuesppSelectBinary ppSelectLabel ppJoinTypeppAttrsnameAsppTables tableAliasppLimitppOffsetppValues ppValuesRowppBinOpppInsertReturningppUpdateReturningPMPackMap traversePMoverPMnewwriterun extractAttrPE extractAttreitherFunction$fSumProfunctorPackMap$fProductProfunctorPackMap$fProfunctorPackMap$fApplicativePackMap$fFunctorPackMapPGString pgFromString PGIntegral PGFractionalpgFromRationalPGNum pgFromIntegerNullableColumnunColumn unsafeCoerce unsafeCastunsafeCompositeFieldunOp unsafeCase_unsafeIfThenElseunsafeGtunsafeEq$fIsStringColumn$fFractionalColumn $fNumColumn $fShowColumnunsafePgFormatTime literalColumn castToTypestrictDecodeUtf8lazyDecodeUtf8PGJsonbPGJsonPGByteaPGArrayPGCitextPGUuid PGTimestamptz PGTimestampPGTime PGNumericPGInt2PGInt8PGFloat8PGFloat4PGDate IsSqlType showPGTypepgStringpgLazyByteStringpgStrictByteString pgStrictText pgLazyTextpgInt4pgInt8pgDoublepgBoolpgUUIDpgDay pgUTCTime pgLocalTime pgTimeOfDaypgCiStrictText pgCiLazyTextpgJSON pgStrictJSON pgLazyJSON pgValueJSONpgJSONB pgStrictJSONB pgLazyJSONB pgValueJSONBpgArray$fIsSqlTypePGJsonb$fIsSqlTypePGJson$fIsSqlTypeNullable$fIsSqlTypePGArray$fIsSqlTypePGBytea$fIsSqlTypePGCitext$fIsSqlTypePGUuid$fIsSqlTypePGTimestamptz$fIsSqlTypePGTimestamp$fIsSqlTypePGTime$fIsSqlTypePGText$fIsSqlTypePGNumeric$fIsSqlTypePGInt2$fIsSqlTypePGInt4$fIsSqlTypePGInt8$fIsSqlTypePGFloat8$fIsSqlTypePGFloat4$fIsSqlTypePGDate$fIsSqlTypePGBool$fPGStringPGCitext$fPGStringPGText$fPGIntegralPGInt8$fPGIntegralPGInt4$fPGIntegralPGInt2$fPGFractionalPGFloat8 $fPGNumPGInt8 $fPGNumPGInt4$fPGNumPGFloat8nullisNull matchNullable fromNullable toNullablemaybeToNullableConstantconstantExplicitconstant$fSumProfunctorConstant$fProductProfunctorConstant$fProfunctorConstant$fApplicativeConstant$fFunctorConstant$fDefaultConstant[]Column$fDefaultConstantMaybeMaybe$fDefaultConstantValueColumn!$fDefaultConstantByteStringColumn"$fDefaultConstantByteStringColumn0$fDefaultConstantValueColumn0"$fDefaultConstantByteStringColumn1"$fDefaultConstantByteStringColumn2$fDefaultConstantCIColumn$fDefaultConstantCIColumn0 $fDefaultConstantTimeOfDayColumn $fDefaultConstantLocalTimeColumn$fDefaultConstantUTCTimeColumn$fDefaultConstantDayColumn$fDefaultConstantUUIDColumn$fDefaultConstantBoolColumn$fDefaultConstantDoubleColumn$fDefaultConstantInt64Column$fDefaultConstantInt32Column$fDefaultConstantIntColumn$fDefaultConstantTextColumn$fDefaultConstantTextColumn0"$fDefaultConstantByteStringColumn3"$fDefaultConstantByteStringColumn4$fDefaultConstant[]Column0$fDefaultConstantMaybeColumn UnpackspecunpackspecColumn runUnpackspec collectPEs$fSumProfunctorUnpackspec$fProductProfunctorUnpackspec$fProfunctorUnpackspec$fApplicativeUnpackspec$fFunctorUnpackspec$fDefaultUnpackspecColumnColumnQueryQueryArrsimpleQueryArr runQueryArrrunSimpleQueryArrrunSimpleQueryArrStartrunQueryArrUnpackfirst3$fProductProfunctorQueryArr$fProfunctorQueryArr$fApplicativeQueryArr$fFunctorQueryArr$fArrowQueryArr$fCategoryTYPEQueryArrshowSqlForPostgresshowSqlForPostgresUnoptshowSqlForPostgresExplicitshowSqlForPostgresUnoptExplicitformatAndShowSQL BinaryspecextractBinaryFields runBinaryspecbinaryspecColumnsameTypeBinOpHelper$fProductProfunctorBinaryspec$fProfunctorBinaryspec$fApplicativeBinaryspec$fFunctorBinaryspec$fDefaultBinaryspecColumnColumn ValuesspecvaluesUextractValuesEntryextractValuesField runValuesspec$fProductProfunctorValuesspec$fProfunctorValuesspec$fApplicativeValuesspec$fFunctorValuesspec$fDefaultValuesspecColumnColumnvaluesExplicit NullMaker joinExplicit$fProductProfunctorNullMaker$fProfunctorNullMaker$fApplicativeNullMaker$fFunctorNullMaker$fDefaultNullMakerColumnColumn$fDefaultNullMakerColumnColumn0leftJoin rightJoinfullJoinleftJoinExplicitrightJoinExplicitfullJoinExplicitqueryRunnerColumnDefault QueryRunnerQueryRunnerColumnfieldQueryRunnerColumnfieldParserQueryRunnerColumn queryRunnerqueryRunnerColumnNullable arrayColumnarrayFieldParser fromArrayjsonFieldParserjsonbFieldParserjsonFieldTypeParserprepareRowParser$fSumProfunctorQueryRunner$fProductProfunctorQueryRunner$fProfunctorQueryRunner$fApplicativeQueryRunner$fFunctorQueryRunner#$fQueryRunnerColumnDefaultPGArray[]&$fQueryRunnerColumnDefaultPGJsonbValue#$fQueryRunnerColumnDefaultPGJsonb[]%$fQueryRunnerColumnDefaultPGJsonValue"$fQueryRunnerColumnDefaultPGJson[]$$fQueryRunnerColumnDefaultPGCitextCI%$fQueryRunnerColumnDefaultPGCitextCI0)$fQueryRunnerColumnDefaultPGTimeTimeOfDay.$fQueryRunnerColumnDefaultPGTimestampLocalTime.$fQueryRunnerColumnDefaultPGTimestamptzUTCTime#$fQueryRunnerColumnDefaultPGDateDay$$fQueryRunnerColumnDefaultPGTextText%$fQueryRunnerColumnDefaultPGTextText0+$fQueryRunnerColumnDefaultPGByteaByteString,$fQueryRunnerColumnDefaultPGByteaByteString0$$fQueryRunnerColumnDefaultPGUuidUUID$$fQueryRunnerColumnDefaultPGBoolBool($fQueryRunnerColumnDefaultPGFloat8Double"$fQueryRunnerColumnDefaultPGText[]%$fQueryRunnerColumnDefaultPGInt8Int64%$fQueryRunnerColumnDefaultPGInt4Int32#$fQueryRunnerColumnDefaultPGInt4Int$fDefaultQueryRunnerColumnb'$fQueryRunnerColumnDefaultNullableMaybe$fFunctorQueryRunnerColumnrunQuery runQueryFoldrunQueryExplicitrunQueryFoldExplicit prepareQueryorderByU orderExprslimit'offset'$fDecidableOrder$fDivisibleOrder $fMonoidOrder$fSemigroupOrder$fContravariantOrderPGOrdascdesc ascNullsFirst descNullsLast$fPGOrdNullable $fPGOrdPGUuid$fPGOrdPGCitext$fPGOrdPGTimestamp$fPGOrdPGTimestamptz $fPGOrdPGTime $fPGOrdPGText$fPGOrdPGNumeric $fPGOrdPGInt2 $fPGOrdPGInt4 $fPGOrdPGInt8$fPGOrdPGFloat4$fPGOrdPGFloat8 $fPGOrdPGDate $fPGOrdPGBool Aggregator makeAggr'makeAggrorderAggregate runAggregator aggregateUextractAggregateFields$fSumProfunctorAggregator$fProductProfunctorAggregator$fProfunctorAggregator$fApplicativeAggregator$fFunctorAggregator ColumnMakerViewColumnMakerrunViewColumnMakerrunColumnMaker tableColumncolumn$fProductProfunctorColumnMaker$fProfunctorColumnMaker$fApplicativeColumnMaker$fFunctorColumnMaker"$fProductProfunctorViewColumnMaker$fProfunctorViewColumnMaker$fApplicativeViewColumnMaker$fFunctorViewColumnMaker $fDefaultColumnMakerColumnColumn $fDefaultViewColumnMaker[]ColumnZipunZipWriterViewTablePropertiestablePropertiesWritertablePropertiesViewTableWithSchematableIdentifiertableProperties queryTable runWriter runWriter'requiredoptional$fFunctorTable"$fProductProfunctorTableProperties$fProfunctorTableProperties$fApplicativeTableProperties$fFunctorTableProperties$fProductProfunctorWriter$fProfunctorWriter$fApplicativeWriter$fFunctorWriter $fMonoidZipqueryTableExplicit runInsertManyrunInsertManyReturning runUpdaterunUpdateReturning runDeleterunInsertReturningExplicitrunInsertManyReturningExplicitrunUpdateReturningExplicitrunInsertReturning arrangeInsertarrangeInsertSqlarrangeInsertManyarrangeInsertManySql arrangeUpdatearrangeUpdateSql arrangeDeletearrangeDeleteSqlarrangeInsertManyReturningarrangeInsertManyReturningSqlarrangeUpdateReturningarrangeUpdateReturningSql RelExprMaker relExprVCM relExprCMEqPP.==.&& eqExplicit relExprColumnrunRelExprMakerrelationValuedExprExplicitrelationValuedExpr$fProductProfunctorRelExprMaker$fProfunctorRelExprMaker$fProductProfunctorEqPP$fProfunctorEqPP$fDefaultRelExprMaker[]Column$fDefaultEqPPColumnColumnunionAllunion intersectAll intersect exceptAllexceptunionAllExplicit unionExplicitintersectAllExplicitintersectExplicitexceptAllExplicitexceptExplicitaggregateOrderedsumcount countStaravgmaxminboolOrboolAnd countRows DistinctspecdistinctExplicit$fSumProfunctorDistinctspec$fProductProfunctorDistinctspec$fProfunctorDistinctspec$fApplicativeDistinctspec$fFunctorDistinctspec!$fDefaultDistinctspecColumnColumndistinct PGJsonIndexPGIsJsonkeepWhen./=.===./==.>.<.<=.>=quot_rem_case_ ifThenElse.||not.++lowerupperlike charLengthorsin_inQuerytimestamptzAtTimeZone emptyArray arrayPrependsingletonArray.->.->>.#>.#>>.@>.<@.?.?|.?& doubleOfInt$fPGJsonIndexPGText$fPGJsonIndexPGInt8$fPGJsonIndexPGInt4$fPGIsJsonPGJsonb$fPGIsJsonPGJsonppSqlDirection ppSqlNullsppColumn&profunctors-5.2-Ftt6hTaJPG87FS5uAEIZltData.Profunctor.Unsafe Profunctor2product-profunctors-0.7.1.0-34ODkXuo2OA7ekIxkTprT2Data.Profunctor.Product.ClassProductProfunctorbaseGHC.Base ApplicativeString%Data.Profunctor.Product.Default.ClassDefault0postgresql-simple-0.5.2.1-L54rsyl3sbX69z9Xb1WEIu$Database.PostgreSQL.Simple.FromField FromField FieldParser Control.ArrowArrowGHC.Listfilter