u}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@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&{&|') Safe-Inferred$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.$  !"#$  !"#$"# !    !"# Safe-Inferred$%&}~'()*+,-. $%&'()*+,-. ()*,$%&+'.-$%&}~'()*+,-. Safe-Inferred/012/012/012/012/012 Safe-Inferred345678345678345678345678 Safe-Inferredvused for hacking in custom SQL|represents a default value#Cast an expression to a given type.Y9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y~u}|{zyxwv^tsrqponmlkjihgfedcba`_T]\[ZYXWVUESRQPONMLKJIHGFCD@BA=?>9:;<9:;<=?>@BACDESRQPONMLKJIHGFT ]\[ZYXWVU^tsrqponmlkjihgfedcba`_u}|{zyxwv~  Safe-Inferred  Safe-Inferred Safe-InferredHM.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 3 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 3.   Safe-InferreddTurn a string into a quoted string. Quote characters and any escaping are handled by this function. NoneyEscape characters that need escaping FIXME: Escaping control characters probably doesn't work in SQLite Need more tests4Quote binary literals using Postgresql's hex format.Name of the table to update.=Conditions which must all be true for a row to be updated.Update the data with this.Name of the table;Criteria which must all be true for a row to be deleted. None<     <     <           None !"#$%&'()* !"#$%&'()* !"#$%&'()* !"#$%&'()*  Safe-Inferred1The  and  instances for 1 a; are too general. For example, they allow you to add two 1 /s. This will be fixed in a subsequent release.+,-./0123456789:;<=>+,-./0123456789:;<12/03456789:;-.>+,=<+,-./0123456789:;<=> Safe-Inferred36 ?@ABCDEFGH?@ABC A?@BCHGFED ?@ABCDEFGH Safe-InferredIJKLMIJKLMIJKLMIJKLM Safe-InferredNAn N$ 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 N corresponds closely to a () from the foldl package. Whereas an N 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. NOPQRSTUVWXYNOPQRST NOPQRSTYXWVU NOPQRSTUVWXYNone<.Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.kjihgfedcba`_^]\[Zlmnopqrstuvwxyz{|}~.Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None<    NoneA NULL of any typeIf 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 the *+ function.If the Column (Nullable a)# is NULL then return the provided Column a! otherwise return the underlying Column a.The Opaleye equivalent of the *, functionThe Opaleye equivalent of *-If the argument is *.M return NULL otherwise return the provided value coerced to a nullable type.XCast a column to any other type. This is safe for some conversions such as uuid to text. /145 1/45None246An  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 1Modify all the targeted ~sExtract all the targeted ~s   None /NoneNone3MExample type specialization: ;showSqlForPostgres :: Query (Column a, Column b) -> String  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: MshowSqlForPostgres :: Query (Foo (Column a) (Column b) (Column c)) -> String None246   None3Example 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)) None2346None2346leftJoin'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 leftJoin.Example specialization: leftJoin :: Query (Column a, Column b) -> Query (Column c, Column (Nullable d)) -> (((Column a, Column b), (Column c, Column (Nullable d))) -> Column 01W) -> Query ((Column a, Column b), (Column (Nullable c), Column (Nullable d))) None2346A  pgType  haskellType' represents the default way to turn a pgType8 result from the database into a Haskell value of type  haskelType.Have 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.A  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  c  encodes how to turn a PGText* result from the database into a Haskell . None3runQuery'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 02 , Column 03&) -> IO [(Column Int, Column String)]  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: runQuery :: Query (Foo (Column 02 ) (Column 03 ) (Column 01C) -> IO [(Foo (Column Int) (Column String) (Column Bool)] HOpaleye types are converted to Haskell types based on instances of the 45 typeclass.Use X to make an instance to allow you to run queries on your own datatypes. For example: cnewtype Foo = Foo Int instance Default QueryRunnerColumn Foo Foo where def = queryRunnerColumn (67) :: Column Foo -> Column PGInt4) Foo def NoneAn E represents an expression to order on and a sort direction. Multiple s can be composed with 890. 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  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 f, 1 c ) ->  (1 f, 1 c ) 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.            None nRestrict query results to a particular condition. Corresponds to the guard method of the MonadPlus class.     None246 !"#$%&'()*+,-./01 !"#$%&'"# !$%&'10/.-,+*)( !"#$%&'()*+,-./01!None3HM;Define a table as follows, where "id", "color", "location", "quantity" and "radius" are the tables columns in Postgres and the types are given in the type signature. The id@ field is an autoincrementing field (i.e. optional for writes). data Widget a b c d e = Widget { wid :: a , color :: b , location :: c , quantity :: d , radius :: e } $(:; "pWidget" ''Widget) widgetTable :: Table (Widget (Maybe (Column PGInt4)) (Column PGText) (Column PGText) (Column PGInt4) (Column PGFloat8)) (Widget (Column PGText) (Column PGText) (Column PGText) (Column PGInt4) (Column PGFloat8)) widgetTable = Table "widgetTable" (pWidget Widget { wid = optional "id" , color = required "color" , location = required "location" , quantity = required "quantity" , radius = required "radius" }) 23456789:;<=>?@ABCDEFGHIJKL23456789:;<=>?@AB;<9:7856=>?@234LABKJIHGFEDC23456789:;<=>?@ABCDEFGHIJKL"None3MExample 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)) MNOP 579;<MNOP MNOP75;<9MNOP#None3arunInsertReturning'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.QRSTUVWXYZ[\]^_`abcdeQRSTUVWXYZ[\]^_`abcdeQRSTUVWXYZ[\]^_`abcdeQRSTUVWXYZ[\]^_`abcde$None36fExample type specialization: uunionAll :: Query (Column a, Column b) -> Query (Column a, Column b) -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: unionAll :: Query (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c)) fgfgfgfg%NonehGiven a  producing rows of type a and an N accepting rows of type a3, apply the aggregator to the results of the query.i2Group the aggregation by equality on the input to i.jSum all rows in a group.k-Count the number of non-null rows in a group.lAverage of a groupmMaximum of a groupnMaximum of a group hijklmnopqr Nhijklmnopqr hijklmnopqrN hijklmnopqr&None6 stuvwxyz{stu ust{zyxwvstuvwxyz{'None3|-Remove duplicate items from the query result.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)) |u||u|<None/145NZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 579;<MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqru|==>>??@ABCDEFGHIJKLMNOOPQRSTUVWXYYZZ[\]^_`abcdefghijklmnoppqrstuvwxyyz{|}~                                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ b \ A B C D E F G H I J K L L M M N 7 O 2 P Q R S T U V WXXYZ[\]^_`abcdeffghijklmnopqrstuvwxy3z{2|}~1baU/5,      ! ! " " # $ % & ' ( ) * + , - . / 0!1!1!2!3!3!4!4!5!5!#!#!6!$!7!8!9!:!;!<!=!>!?!@!A!B!C!D"6"E"9":#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&f&g&h&i&j&k&l&m'nopqrstuvwxyzx{ x|}x~uopaleye-sqlite-0.0.0.1%Opaleye.SQLite.Internal.HaskellDB.Sql+Opaleye.SQLite.Internal.HaskellDB.Sql.PrintOpaleye.SQLite.Internal.HelpersOpaleye.SQLite.Internal.Tag+Opaleye.SQLite.Internal.HaskellDB.PrimQuery!Opaleye.SQLite.Internal.PrimQuery Opaleye.SQLite.Internal.OptimizeOpaleye.SQLite.Internal.PackMap.Opaleye.SQLite.Internal.HaskellDB.Sql.Generate-Opaleye.SQLite.Internal.HaskellDB.Sql.DefaultOpaleye.SQLite.Internal.SqlOpaleye.SQLite.Internal.PrintOpaleye.SQLite.Internal.ColumnOpaleye.SQLite.Internal.BinaryOpaleye.SQLite.Internal.PGTypes!Opaleye.SQLite.Internal.AggregateOpaleye.SQLite.PGTypesOpaleye.SQLite.SqlTypesOpaleye.SQLite.Column"Opaleye.SQLite.Internal.Unpackspec Opaleye.SQLite.Internal.QueryArrOpaleye.SQLite.SqlOpaleye.SQLite.Internal.ValuesOpaleye.SQLite.ValuesOpaleye.SQLite.Internal.JoinOpaleye.SQLite.Join Opaleye.SQLite.Internal.RunQueryOpaleye.SQLite.RunQueryOpaleye.SQLite.Internal.OrderOpaleye.SQLite.OrderOpaleye.SQLite.Operators"Opaleye.SQLite.Internal.TableMakerOpaleye.SQLite.Internal.TableOpaleye.SQLite.TableOpaleye.SQLite.ManipulationOpaleye.SQLite.BinaryOpaleye.SQLite.Aggregate Opaleye.SQLite.Internal.DistinctOpaleye.SQLite.Distinct Control.FoldlFold Data.Maybemaybe fromMaybeJustNothingOpaleye.SQLite.QueryArrOpaleye.PGTypesPGBoolPGInt4PGTextOpaleye.Internal.RunQueryQueryRunnerColumnDefaultOpaleye.Column unsafeCoerce Data.MonoidmappendData.Profunctor.Product.THmakeAdaptorAndInstanceOpaleye.SQLite SqlInsert SqlDelete SqlUpdateSqlExprDefaultSqlExpr CastSqlExpr ParensSqlExprPlaceHolderSqlExpr ParamSqlExpr ListSqlExpr CaseSqlExpr ConstSqlExprAggrFunSqlExpr FunSqlExprPostfixSqlExpr PrefixSqlExpr BinSqlExpr ColumnSqlExprSqlOrdersqlOrderDirection sqlOrderNullsSqlOrderDirectionSqlDescSqlAsc SqlOrderNulls SqlNullsLast SqlNullsFirstSqlName SqlColumnSqlTableppWhere ppGroupBy ppOrderByppAsppUpdateppDeleteppInsertppTable ppSqlExprcommaHcommaV.:.:..::.::.Tag UnsafeTagstartnext unsafeUnTagtagWithOrderOporderDirection orderNullsOrderDirectionOpDescOpAsc OrderNulls NullsLast NullsFirst OrderExprAggrOp AggrOtherAggrStringAggrAggrArr AggrBoolAnd AggrBoolOrAggrVarPAggrVar AggrStdDevP AggrStdDevAggrMaxAggrMinAggrAvgAggrSum AggrCountUnOp UnOpOtherOpUpperOpLowerOpNegateOpAbsOpLength OpIsNotNullOpIsNullOpNotBinOpOpAsgOpBitXorOpBitOrOpBitAndOpBitNotOpModOpDivOpMulOpMinusOpPlusOpCatOpOtherOpInOpLikeOpOrOpAndOpNotEqOpGtEqOpGtOpLtEqOpLtOpEqLiteralOtherLit DoubleLit IntegerLit ByteStringLit StringLitBoolLit DefaultLitNullLitPrimExprDefaultInsertExprCastExprFunExpr ParamExprListExprCaseExpr ConstExprAggrExprUnExprBinExprBaseTableAttrExprAttrExprSymbolAssocSchemeName Attribute TableName PrimQueryFold PrimQueryBinaryValuesJoinLimitOrder AggregateProduct BaseTableUnitJoinTypeLeftJoinUnionAllUnionExceptLimitOp LimitOffsetOpOffsetOp foldPrimQuerytimesrestrictisUnitoptimize removeUnit mergeProductPMPackMap traversePMoverPMnewwriterun extractAttrPE extractAttreitherFunction$fSumProfunctorPackMap$fProductProfunctorPackMap$fProfunctorPackMap$fApplicativePackMap$fFunctorPackMap SqlGenerator sqlUpdate sqlDelete sqlInsertsqlExpr sqlLiteralsqlQuoteUnOpType UnOpPostfix UnOpPrefixUnOpFunmkSqlGeneratordefaultSqlGenerator toSqlOrder toSqlColumn toSqlAssocdefaultSqlUpdatedefaultSqlInsertdefaultSqlDeletedefaultSqlExpr showBinOpsqlUnOp showAggrOpdefaultSqlLiteraldefaultSqlQuotequoteescapebinQuote ReturningStringbOpbSelect1bSelect2vAttrsvValues jJoinTypejTablesjCondFromattrstablescriteriagroupByorderBylimitoffset SelectAttrsStarSelect SelectBinary SelectValues SelectJoinTable SelectFromsqlQueryGeneratorsqlunit baseTableproduct aggregateaggrExprorderlimit_joinvaluesbinaryjoinTypebinOp newSelect sqlBinding ensureColumns TableAliasppSql ppSelectFrom ppSelectJoinppSelectValuesppSelectBinary ppJoinTypeppAttrsnameAsppTables tableAliasppLimitppOffsetppValues ppValuesRowppBinOpppInsertReturningppUpdateReturning PGFractionalpgFromRationalPGNum pgFromIntegerNullableColumnunColumnunsafeCoerceColumnunOp unsafeCase_unsafeIfThenElseunsafeGtunsafeEq unsafeCast$fFractionalColumn $fNumColumn BinaryspecextractBinaryFields runBinaryspecbinaryspecColumn$fProductProfunctorBinaryspec$fProfunctorBinaryspec$fApplicativeBinaryspec$fFunctorBinaryspec$fDefaultBinaryspecColumnColumnunsafePgFormatTime literalColumn castToTypestrictDecodeUtf8lazyDecodeUtf8 Aggregator makeAggr'makeAggr runAggregator aggregateUextractAggregateFields$fSumProfunctorAggregator$fProductProfunctorAggregator$fProfunctorAggregator$fApplicativeAggregator$fFunctorAggregatorPGJsonbPGJsonPGByteaPGArrayPGCitextPGUuid PGTimestamptz PGTimestampPGTime PGNumericPGInt2PGInt8PGFloat8PGFloat4PGDatepgStringpgLazyByteStringpgStrictByteString pgStrictText pgLazyTextpgInt4pgInt8pgDoublepgBoolpgUUIDpgDay pgUTCTime pgLocalTime pgTimeOfDaypgCiStrictText pgCiLazyTextpgJSON pgStrictJSON pgLazyJSONpgJSONB pgStrictJSONB pgLazyJSONB$fPGFractionalPGFloat8 $fPGNumPGInt8 $fPGNumPGInt4$fPGNumPGFloat8SqlIntSqlTextSqlRealSqlDateSqlBool sqlString sqlStrictText sqlLazyTextsqlIntsqlRealsqlBoolnullisNull matchNullable fromNullable toNullablemaybeToNullable UnpackspecunpackspecColumn runUnpackspec collectPEs$fSumProfunctorUnpackspec$fProductProfunctorUnpackspec$fProfunctorUnpackspec$fApplicativeUnpackspec$fFunctorUnpackspec$fDefaultUnpackspecColumnColumnQueryQueryArrsimpleQueryArr runQueryArrrunSimpleQueryArrrunSimpleQueryArrStartrunQueryArrUnpackfirst3$fProductProfunctorQueryArr$fProfunctorQueryArr$fApplicativeQueryArr$fFunctorQueryArr$fArrowQueryArr$fCategory*QueryArrshowSqlForPostgresshowSqlForPostgresUnoptshowSqlForPostgresExplicitshowSqlForPostgresUnoptExplicitformatAndShowSQL ValuesspecvaluesUextractValuesEntryextractValuesField runValuesspec$fProductProfunctorValuesspec$fProfunctorValuesspec$fApplicativeValuesspec$fFunctorValuesspec$fDefaultValuesspecColumnColumnvaluesExplicit NullMakerextractLeftJoinFields$fProductProfunctorNullMaker$fProfunctorNullMaker$fDefaultNullMakerColumnColumn$fDefaultNullMakerColumnColumn0leftJoinleftJoinExplicitqueryRunnerColumnDefault QueryRunnerQueryRunnerColumnfieldQueryRunnerColumn queryRunnerqueryRunnerColumnNullable$fSumProfunctorQueryRunner$fProductProfunctorQueryRunner$fProfunctorQueryRunner$fApplicativeQueryRunner$fFunctorQueryRunner.$fQueryRunnerColumnDefaultPGTimestamptzUTCTime#$fQueryRunnerColumnDefaultPGDateDay$$fQueryRunnerColumnDefaultPGTextText%$fQueryRunnerColumnDefaultPGTextText0+$fQueryRunnerColumnDefaultPGByteaByteString,$fQueryRunnerColumnDefaultPGByteaByteString0$$fQueryRunnerColumnDefaultPGBoolBool($fQueryRunnerColumnDefaultPGFloat8Double"$fQueryRunnerColumnDefaultPGText[]%$fQueryRunnerColumnDefaultPGInt8Int64#$fQueryRunnerColumnDefaultPGInt4Int$fDefaultQueryRunnerColumnb'$fQueryRunnerColumnDefaultNullableMayberunQueryrunQueryExplicitqueryRunnerColumnorderByUlimit'offset'$fDecidableOrder$fDivisibleOrder $fMonoidOrder$fContravariantOrderPGOrdascdesc ascNullsFirst descNullsLast$fPGOrdPGCitext$fPGOrdPGTimestamp$fPGOrdPGTimestamptz $fPGOrdPGTime $fPGOrdPGText$fPGOrdPGNumeric $fPGOrdPGInt2 $fPGOrdPGInt4 $fPGOrdPGInt8$fPGOrdPGFloat4$fPGOrdPGFloat8 $fPGOrdPGDate $fPGOrdPGBool doubleOfInt.==./=.>.<.<=.>=case_ ifThenElse.&&.||not.++lowerupperlikeorsin_ ColumnMakerViewColumnMakerrunViewColumnMakerrunColumnMaker tableColumncolumn$fProductProfunctorColumnMaker$fProfunctorColumnMaker$fApplicativeColumnMaker$fFunctorColumnMaker"$fProductProfunctorViewColumnMaker$fProfunctorViewColumnMaker$fApplicativeViewColumnMaker$fFunctorViewColumnMaker $fDefaultColumnMakerColumnColumn $fDefaultViewColumnMaker[]ColumnZipunZipWriterViewTableProperties queryTable runWriter runWriter'requiredoptional$fFunctorTable"$fProductProfunctorTableProperties$fProfunctorTableProperties$fApplicativeTableProperties$fFunctorTableProperties$fProductProfunctorWriter$fProfunctorWriter$fApplicativeWriter$fFunctorWriter $fMonoidZipqueryTableExplicitInt64 arrangeInsertarrangeInsertSql runInsertarrangeInsertManyarrangeInsertManySql runInsertMany arrangeUpdatearrangeUpdateSql runUpdate arrangeDeletearrangeDeleteSql runDeletearrangeInsertReturningarrangeInsertReturningSqlrunInsertReturningExplicitrunInsertReturningarrangeUpdateReturningarrangeUpdateReturningSqlrunUpdateReturningExplicitrunUpdateReturningunionAllunionAllExplicitsumcountavgmaxminboolOrboolAndarrayAgg stringAgg DistinctspecdistinctExplicit$fSumProfunctorDistinctspec$fProductProfunctorDistinctspec$fProfunctorDistinctspec$fApplicativeDistinctspec$fFunctorDistinctspec!$fDefaultDistinctspecColumnColumndistinctppSqlDirection ppSqlNullsppColumnprofunctors-5.1.1Data.Profunctor.Unsafe Profunctorproduct-profunctors-0.6.3Data.Profunctor.ProductProductProfunctorbaseControl.Applicative ApplicativeGHC.BaseGHC.NumNumGHC.Real FractionalData.Profunctor.Product.DefaultDefault