h$YiIC      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                   !"""""###$$$$$$$$$$$%%%%%%%%%%%%%%%%&&&&'''''''''''''''''''''((* Safe-Inferred^opaleye-sqlite$Data type for SQL DELETE statements.opaleye-sqlite$Data type for SQL UPDATE statements.opaleye-sqliteExpressions in SQL statements. opaleye-sqlite3Aggregate functions separate from normal functions.opaleye-sqlite!A valid SQL name for a parameter.$  !"#$"# !  Safe-Inferred *+,-./012345 */013+,-2.54 Safe-Inferred 6789678968788898 Safe-InferredP:;<=>?:;<=>? Safe-Inferredopaleye-sqliterepresents a default valueopaleye-sqliteused for hacking in custom SQLopaleye-sqlite#Cast an expression to a given type.BCEDFHGIKJLMN\[ZYXWVUTSRQPO]fedcba`_^g}|{zyxwvutsrqponmlkjih~~g}|{zyxwvutsrqponmlkjih]fedcba`_^N\[ZYXWVUTSRQPOLMIKJFHGBCED Safe-Inferred/ Safe-InferredNoneopaleye-sqlite.A helpful monad for writing columns in the ASTopaleye-sqliteA  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.opaleye-sqlite$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.opaleye-sqlite#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.opaleye-sqlite3Make 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.Add the fresh name and the input value it refers to to the list in the state parameter.opaleye-sqliteAs  but ignores the primExpr? when making the fresh column name and just uses the supplied  and :.    Safe-InferredSopaleye-sqliteTurn a string into a quoted string. Quote characters and any escaping are handled by this function. Noneopaleye-sqliteEscape characters that need escaping FIXME: Escaping control characters probably doesn't work in SQLite Need more testsopaleye-sqlite4Quote binary literals using Postgresql's hex format.opaleye-sqliteName of the table to update.opaleye-sqlite=Conditions which must all be true for a row to be updated.opaleye-sqliteUpdate the data with this.opaleye-sqliteName of the tableopaleye-sqlite;Criteria which must all be true for a row to be deleted. None << None  Safe-InferredWopaleye-sqliteThe  and  instances for  a; are too general. For example, they allow you to add two  /s. This will be fixed in a subsequent release. Safe-InferredNone?None!"opaleye-sqliteAn $ takes a collection of rows of type a, 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.None![**None%opaleye-sqliteA NULL of any typeopaleye-sqliteIf 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.opaleye-sqliteIf the Column (Nullable a)# is NULL then return the provided Column a! otherwise return the underlying Column a.The Opaleye equivalent of the +- functionopaleye-sqliteThe Opaleye equivalent of +.opaleye-sqliteIf the argument is +/ return NULL otherwise return the provided value coerced to a nullable type.opaleye-sqliteCast a column to any other type. This is safe for some conversions such as uuid to text.  None>)opaleye-sqliteAn  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.opaleye-sqliteTarget the single  inside a opaleye-sqliteModify all the targeted sopaleye-sqliteExtract all the targeted sNone>*None*G  None>*None?*None>?.Bopaleye-sqliteA  pgType  haskellType' represents the default way to turn a pgType8 result from the database into a Haskell value of type  haskelType.opaleye-sqliteHave 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.opaleye-sqliteA  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    encodes how to turn a PGText* result from the database into a Haskell .  None/jopaleye-sqliteAn  represents an expression to order on and a sort direction. Multiple s can be composed with 010. If two rows are equal according to the first  , the second is used, and so on.None>?/2None/None4Gopaleye-sqlite?Typeclass for Postgres types which support ordering operations.opaleye-sqliteOrder 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 ::  ( ,   ) ->  ( ,   ) example =  ( fst <>  snd) opaleye-sqliteSpecify an ascending ordering by the given expression. (Any NULLs appear last)opaleye-sqliteSpecify an descending ordering by the given expression. (Any NULLs appear first)opaleye-sqliteSpecify an ascending ordering by the given expression. (Any NULLs appear first)opaleye-sqliteSpecify an descending ordering by the given expression. (Any NULLs appear last)opaleye-sqliteLimit the results of the given query to the given maximum number of items.opaleye-sqliteOffset the results of the given query by the given amount, skipping that many result rows.  None5 opaleye-sqliteRestrict query results to a particular condition. Corresponds to the guard method of the MonadPlus class.44444432None>?7opaleye-sqliteleftJoin'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 34) -> Query ((Column a, Column b), (Column (Nullable c), Column (Nullable d))) None?9opaleye-sqliteExample type specialization: unionAll :: 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)) None;opaleye-sqliteGiven a  producing rows of type a and an  accepting rows of type a3, apply the aggregator to the results of the query.opaleye-sqlite2Group the aggregation by equality on the input to .opaleye-sqliteSum all rows in a group.opaleye-sqlite-Count the number of non-null rows in a group.opaleye-sqliteAverage of a groupopaleye-sqliteMaximum of a groupopaleye-sqliteMaximum of a group   None<!None?=opaleye-sqlite-Remove duplicate items from the query result.Example type specialization: distinct :: Query (Column a, Column b) -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: distinct :: Query (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c)) "None?>opaleye-sqliteExample type specialization: ;showSqlForPostgres :: Query (Column a, Column b) -> String  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: showSqlForPostgres :: Query (Foo (Column a) (Column b) (Column c)) -> String #None?Bopaleye-sqliterunQuery'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 35 , Column 36&) -> IO [(Column Int, Column String)]  Assuming the makeAdaptorAndInstance* splice has been run for the product type Foo: runQuery :: Query (Foo (Column 35 ) (Column 36 ) (Column 34) -> IO [(Foo (Column Int) (Column String) (Column Bool)] Opaleye types are converted to Haskell types based on instances of the 78 typeclass.opaleye-sqliteUse  to make an instance to allow you to run queries on your own datatypes. For example: newtype Foo = Foo Int instance Default QueryRunnerColumn Foo Foo where def = queryRunnerColumn (9:) :: Column Foo -> Column PGInt4) Foo def $NoneC,  %None>?C}&None?Eopaleye-sqliteExample type specialization: queryTable :: Table w (Column a, Column b) -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: queryTable :: Table w (Foo (Column a) (Column b) (Column c)) -> Query (Foo (Column a) (Column b) (Column c))  'None?F6opaleye-sqliterunInsertReturning'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.(None?Gopaleye-sqliteExample type specialization: ?values :: [(Column a, Column b)] -> Query (Column a, Column b)  Assuming the makeAdaptorAndInstance+ splice has been run for the product type Foo: queryTable :: [Foo (Column a) (Column b) (Column c)] -> Query (Foo (Column a) (Column b) (Column c)) ;NoneH<<==>>?@ABCDEFGHIJKLMNNOPQRSTUVWXXYYZ[\]^_`abcdefghijklmnopqrstuvwxxyz{|}~                                                                                                             h b                 :           6548         !"""""###$$$$$$$$$$$%%%%%%%%%%%%%%%%&&&&'''''''''''''''''''''((-opaleye-sqlite-0.0.1.1-1qbLiRGZ93S2JY1vjoM0BP%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.PGTypesOpaleye.SQLite.Internal.Binary!Opaleye.SQLite.Internal.AggregateOpaleye.SQLite.PGTypesOpaleye.SQLite.Column"Opaleye.SQLite.Internal.UnpackspecOpaleye.SQLite.Internal.Values Opaleye.SQLite.Internal.QueryArr"Opaleye.SQLite.Internal.TableMakerOpaleye.SQLite.Internal.Table Opaleye.SQLite.Internal.RunQueryOpaleye.SQLite.Internal.OrderOpaleye.SQLite.Internal.JoinOpaleye.SQLite.OrderOpaleye.SQLite.OperatorsOpaleye.SQLite.JoinOpaleye.SQLite.BinaryOpaleye.SQLite.Aggregate Opaleye.SQLite.Internal.DistinctOpaleye.SQLite.DistinctOpaleye.SQLite.SqlOpaleye.SQLite.RunQueryOpaleye.SQLite.SqlTypesOpaleye.SQLite.ConstantOpaleye.SQLite.TableOpaleye.SQLite.ManipulationOpaleye.SQLite.Values Control.FoldlFold Data.Maybemaybe fromMaybeJustNothing Data.MonoidmappendOpaleye.SQLite.QueryArrOpaleye.PGTypesPGBoolPGInt4PGTextOpaleye.Internal.RunQueryQueryRunnerColumnDefaultOpaleye.Column unsafeCoerceOpaleye.SQLite SqlInsert SqlDelete SqlUpdateSqlExpr ColumnSqlExpr BinSqlExpr PrefixSqlExprPostfixSqlExpr FunSqlExprAggrFunSqlExpr ConstSqlExpr CaseSqlExpr ListSqlExpr ParamSqlExprPlaceHolderSqlExpr ParensSqlExpr CastSqlExprDefaultSqlExprSqlOrdersqlOrderDirection sqlOrderNullsSqlOrderDirectionSqlAscSqlDesc SqlOrderNulls SqlNullsFirst SqlNullsLastSqlName SqlColumnSqlTable $fShowSqlExpr$fShowSqlOrder$fShowSqlOrderDirection$fShowSqlOrderNulls$fShowSqlColumn$fShowSqlTable deliteralppWhere ppGroupBy ppOrderByppAsppUpdateppDeleteppInsertppTable ppSqlExprcommaHcommaV.:.:..::.::.Tag UnsafeTagstartnext unsafeUnTagtagWith $fReadTag $fShowTagOrderOporderDirection orderNullsOrderDirectionOpAscOpDesc OrderNulls NullsFirst NullsLast OrderExprAggrOp AggrCountAggrSumAggrAvgAggrMinAggrMax AggrStdDev AggrStdDevPAggrVarAggrVarP AggrBoolOr AggrBoolAndAggrArrAggrStringAggr AggrOtherUnOpOpNotOpIsNull OpIsNotNullOpLengthOpAbsOpNegateOpLowerOpUpper UnOpOtherBinOpOpEqOpLtOpLtEqOpGtOpGtEqOpNotEqOpAndOpOrOpLikeOpInOpOtherOpCatOpPlusOpMinusOpMulOpDivOpModOpBitNotOpBitAndOpBitOrOpBitXorOpAsgLiteralNullLit DefaultLitBoolLit StringLit ByteStringLit IntegerLit DoubleLitOtherLitPrimExprAttrExprBaseTableAttrExprBinExprUnExprAggrExpr ConstExprCaseExprListExpr ParamExprFunExprCastExprDefaultInsertExprSymbolAssocSchemeName Attribute TableName$fShowOrderExpr $fShowOrderOp$fShowOrderDirection$fShowOrderNulls $fShowAggrOp $fReadAggrOp$fReadPrimExpr$fShowPrimExpr $fShowUnOp $fReadUnOp $fShowBinOp $fReadBinOp $fReadLiteral $fShowLiteral $fReadSymbol $fShowSymbol PrimQueryFold PrimQueryUnit BaseTableProduct AggregateOrderLimitJoinValuesBinaryJoinTypeLeftJoinExceptUnionUnionAllLimitOpOffsetOp LimitOffsetOp foldPrimQuerytimesrestrictisUnit$fShowPrimQuery$fShowJoinType $fShowLimitOpoptimize removeUnit mergeProductPMPackMap traversePMoverPMnewwriterun extractAttrPE extractAttreitherFunction$fSumProfunctorPackMap$fProductProfunctorPackMap$fProfunctorPackMap$fApplicativePackMap$fFunctorPackMap SqlGenerator sqlUpdate sqlDelete sqlInsertsqlExpr sqlLiteralsqlQuoteUnOpTypeUnOpFun UnOpPrefix UnOpPostfixmkSqlGeneratordefaultSqlGenerator toSqlOrder toSqlColumn toSqlAssocdefaultSqlUpdatedefaultSqlInsertdefaultSqlDeletedefaultSqlExpr showBinOpsqlUnOp showAggrOpdefaultSqlLiteraldefaultSqlQuotequoteescapebinQuote ReturningStringbOpbSelect1bSelect2vAttrsvValues jJoinTypejTablesjCondFromattrstablescriteriagroupByorderBylimitoffset SelectAttrsStarSelect SelectFromTable SelectJoin SelectValues SelectBinarysqlQueryGeneratorsqlunit baseTableproduct aggregateaggrExprorderlimit_joinvaluesbinaryjoinTypebinOp newSelect sqlBinding ensureColumns $fShowBinary $fShowSelect $fShowJoin $fShowFrom $fShowValues$fShowSelectAttrs TableAliasppSql ppSelectFrom ppSelectJoinppSelectValuesppSelectBinary ppJoinTypeppAttrsnameAsppTables tableAliasppLimitppOffsetppValues ppValuesRowppBinOpppInsertReturningppUpdateReturning PGFractionalpgFromRationalPGNum pgFromIntegerNullableColumnunColumnunsafeCoerceColumnunOp unsafeCase_unsafeIfThenElseunsafeGtunsafeEq unsafeCast $fNumColumn$fFractionalColumn $fShowColumnunsafePgFormatTime literalColumn castToTypestrictDecodeUtf8lazyDecodeUtf8 BinaryspecextractBinaryFields runBinaryspecbinaryspecColumn$fProductProfunctorBinaryspec$fProfunctorBinaryspec$fApplicativeBinaryspec$fFunctorBinaryspec$fDefaultBinaryspecColumnColumn Aggregator makeAggr'makeAggr runAggregator aggregateUextractAggregateFields$fSumProfunctorAggregator$fProductProfunctorAggregator$fProfunctorAggregator$fApplicativeAggregator$fFunctorAggregatorPGJsonbPGJsonPGByteaPGArrayPGCitextPGUuid PGTimestamptz PGTimestampPGTime PGNumericPGInt2PGInt8PGFloat8PGFloat4PGDatepgStringpgLazyByteStringpgStrictByteString pgStrictText pgLazyTextpgInt4pgInt8pgDoublepgBoolpgUUIDpgDay pgUTCTime pgLocalTime pgTimeOfDaypgCiStrictText pgCiLazyTextpgJSON pgStrictJSON pgLazyJSONpgJSONB pgStrictJSONB pgLazyJSONB$fPGFractionalPGFloat8$fPGNumPGFloat8 $fPGNumPGInt8 $fPGNumPGInt4nullisNull matchNullable fromNullable toNullablemaybeToNullable UnpackspecunpackspecColumn runUnpackspec collectPEs$fSumProfunctorUnpackspec$fProductProfunctorUnpackspec$fProfunctorUnpackspec$fApplicativeUnpackspec$fFunctorUnpackspec$fDefaultUnpackspecColumnColumn ValuesspecvaluesUextractValuesEntryextractValuesField runValuesspec$fProductProfunctorValuesspec$fProfunctorValuesspec$fApplicativeValuesspec$fFunctorValuesspec$fDefaultValuesspecColumnColumnQueryQueryArrsimpleQueryArr runQueryArrrunSimpleQueryArrrunSimpleQueryArrStartrunQueryArrUnpackfirst3$fProductProfunctorQueryArr$fProfunctorQueryArr$fApplicativeQueryArr$fFunctorQueryArr$fArrowQueryArr$fCategoryTYPEQueryArr ColumnMakerViewColumnMakerrunViewColumnMakerrunColumnMaker tableColumncolumn"$fProductProfunctorViewColumnMaker$fProfunctorViewColumnMaker$fApplicativeViewColumnMaker$fFunctorViewColumnMaker $fDefaultViewColumnMaker[]Column$fProductProfunctorColumnMaker$fProfunctorColumnMaker$fApplicativeColumnMaker$fFunctorColumnMaker $fDefaultColumnMakerColumnColumnZipunZipWriterViewTableProperties queryTable runWriter runWriter'requiredoptional$fProductProfunctorWriter$fProfunctorWriter$fApplicativeWriter$fFunctorWriter"$fProductProfunctorTableProperties$fProfunctorTableProperties$fApplicativeTableProperties$fFunctorTableProperties$fFunctorTable $fMonoidZip$fSemigroupZipqueryRunnerColumnDefault QueryRunnerQueryRunnerColumnfieldQueryRunnerColumn queryRunnerqueryRunnerColumnNullable$fSumProfunctorQueryRunner$fProductProfunctorQueryRunner$fProfunctorQueryRunner$fApplicativeQueryRunner$fFunctorQueryRunner.$fQueryRunnerColumnDefaultPGTimestamptzUTCTime#$fQueryRunnerColumnDefaultPGDateDay$$fQueryRunnerColumnDefaultPGTextText%$fQueryRunnerColumnDefaultPGTextText0+$fQueryRunnerColumnDefaultPGByteaByteString,$fQueryRunnerColumnDefaultPGByteaByteString0$$fQueryRunnerColumnDefaultPGBoolBool($fQueryRunnerColumnDefaultPGFloat8Double"$fQueryRunnerColumnDefaultPGText[]%$fQueryRunnerColumnDefaultPGInt8Int64#$fQueryRunnerColumnDefaultPGInt4Int$fDefaultQueryRunnerColumnb'$fQueryRunnerColumnDefaultNullableMaybeorderByUlimit'offset'$fDecidableOrder$fDivisibleOrder $fMonoidOrder$fSemigroupOrder$fContravariantOrder NullMakerextractLeftJoinFields$fProductProfunctorNullMaker$fProfunctorNullMaker$fDefaultNullMakerColumnColumn$fDefaultNullMakerColumnColumn0PGOrdascdesc ascNullsFirst descNullsLast$fPGOrdPGCitext$fPGOrdPGTimestamp$fPGOrdPGTimestamptz $fPGOrdPGTime $fPGOrdPGText$fPGOrdPGNumeric $fPGOrdPGInt2 $fPGOrdPGInt4 $fPGOrdPGInt8$fPGOrdPGFloat4$fPGOrdPGFloat8 $fPGOrdPGDate $fPGOrdPGBool doubleOfInt.==./=.>.<.<=.>=case_ ifThenElse.&&.||not.++lowerupperlikeorsin_leftJoinleftJoinExplicitunionAllunionAllExplicitsumcountavgmaxminboolOrboolAndarrayAgg stringAgg DistinctspecdistinctExplicit$fSumProfunctorDistinctspec$fProductProfunctorDistinctspec$fProfunctorDistinctspec$fApplicativeDistinctspec$fFunctorDistinctspec!$fDefaultDistinctspecColumnColumndistinctshowSqlForPostgresshowSqlForPostgresUnoptshowSqlForPostgresExplicitshowSqlForPostgresUnoptExplicitformatAndShowSQLrunQueryrunQueryExplicitqueryRunnerColumnSqlIntSqlTextSqlRealSqlDateSqlBool sqlString sqlStrictText sqlLazyTextsqlIntsqlRealsqlBoolConstantconstantExplicitconstant$fSumProfunctorConstant$fProductProfunctorConstant$fProfunctorConstant$fApplicativeConstant$fFunctorConstant$fDefaultConstantBoolColumn$fDefaultConstantDoubleColumn$fDefaultConstantTextColumn$fDefaultConstantTextColumn0$fDefaultConstant[]Column$fDefaultConstantIntColumn$fDefaultConstantMaybeColumnqueryTableExplicitInt64 arrangeInsertarrangeInsertSql runInsertarrangeInsertManyarrangeInsertManySql runInsertMany arrangeUpdatearrangeUpdateSql runUpdate arrangeDeletearrangeDeleteSql runDeletearrangeInsertReturningarrangeInsertReturningSqlrunInsertReturningExplicitrunInsertReturningarrangeUpdateReturningarrangeUpdateReturningSqlrunUpdateReturningExplicitrunUpdateReturningvaluesExplicit(profunctors-5.5.2-Jd7sxJvE4zaBkftBvoi6oJData.Profunctor.Unsafe Profunctor3product-profunctors-0.11.0.1-E7STr4S4vB0FHmXDS1YdJnData.Profunctor.Product.ClassProductProfunctorbaseGHC.Base ApplicativeGHC.NumNumGHC.Real Fractional%Data.Profunctor.Product.Default.ClassDefault