h$r`      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq r s t u v w x y z { | } ~                                                                                              None" #$&'(-/2348>?None" #$&'(-/2348>? 2postgresql-queryOption for field instructing A# what to do with field when logging3postgresql-query(Do nothing. Field should be pasted as is4postgresql-query$Mask field in logs with placeholder.5postgresql-queryResult if SqlBuilder. Contains separated builder for query and log.Apostgresql-queryFunction modifying query parameter value before pasting it to log.Bpostgresql-query/Simply replaces masked fields with placeholder.Cpostgresql-query?Masks fields which size is bigger than given argument in bytes. 23456789ABC 56789234ABCNone" #$&'(-/2348>? Epostgresql-query7Builder wich can be effectively concatenated. Requires + inside for string quoting implemented in libpq. Builds two strings: query string and log string which may differ.Hpostgresql-query(Returns query string with log bytestringIpostgresql-queryTyped synonym of Jpostgresql-query;Shorthand function to convert single field value to builderKpostgresql-queryShorthand function to convert single masked field value (which should not be shown in log)Mpostgresql-query Lift pure bytestring builder to E/. This is unsafe to use directly in your code.Npostgresql-queryUnsafe function to make SqlBuilder from arbitrary ByteString. Does not perform any checks. Dont use it directly in your code unless you know what you are doing. EFGHIJKLMN EFGHIJKLMNNone" #$&'(-/2348>?HSpostgresql-query*Things which always can be transformed to ESTSTNone" #$&'(-/2348>?23456789ABCEFGHIJKLMNSTNone" #$&'(-/2348>?Xpostgresql-queryReturn constructor nameYpostgresql-query"Return count of constructor fieldsZpostgresql-query'Get field names from record constructorXYZ[\XYZ[\None" #$&'(-/2348>?S]postgresql-queryFunction to transform constructor name into its PG enum conterpart.^postgresql-queryderives  and %# instances for a sum-type enum like !data Entity = Red | Green | Blue ^postgresql-query?mapping function from haskell constructor name to PG enum labelpostgresql-querytype to derive instances for]^^]None" #$&'(-/2348>?_postgresql-queryDerive ' instance. i.e. you have type like that data Entity = Entity { eField :: Text , eField2 :: Int , efield3 :: Bool } then _; will generate this instance: instance FromRow Entity where instance FromRow Entity where fromRow = Entity <$> field <*> field <*> field Datatype must have just one constructor with arbitrary count of fields`postgresql-queryderives $ instance for datatype like data Entity = Entity { eField :: Text , eField2 :: Int , efield3 :: Bool } "it will derive instance like that: instance ToRow Entity where toRow (Entity e1 e2 e3) = [ toField e1 , toField e2 , toField e3 ] _`_`None" #$&'(-/2348>?| apostgresql-query+Internal type. Result of parsing sql stringbpostgresql-queryPart of raw sqlcpostgresql-query Sql commentdpostgresql-querySequence of spacesepostgresql-query&String with haskell expression inside #{..} or #?{..}fpostgresql-query&String with haskell expression inside ^{..}gpostgresql-queryMaybe the main feature of all library. Quasiquoter which builds E from string query. Removes line comments and block comments (even nested) and sequences of spaces. Correctly works handles string literals and quoted identifiers. Here is examples of usagelet name = "name"let val = "some 'value'"run [sqlExp|SELECT * FROM tbl WHERE ^{Identifier name} = #{val}|]5"SELECT * FROM tbl WHERE \"name\" = 'some ''value'''"And more comples example:let name = Just "name"let size = Just 10"let active = Nothing :: Maybe Boollet condlist = catMaybes [ fmap (\a -> [sqlExp|name = #{a}|]) name, fmap (\a -> [sqlExp|size = #{a}|]) size, fmap (\a -> [sqlExp|active = #{a}|]) active]let cond = if L.null condlist then mempty else [sqlExp| WHERE ^{mconcat $ L.intersperse " AND " $ condlist} |]9run [sqlExp|SELECT * FROM tbl ^{cond} -- line comment|]8"SELECT * FROM tbl WHERE name = 'name' AND size = 10 "jpostgresql-query"Removes sequential occurencies of b constructors. Also removes commentaries and squash sequences of spaces to single space symbolkpostgresql-queryBuild expression of type E" from SQL query with interpolationlpostgresql-query,Embed sql template and perform interpolation let name = "name" foo = "bar" query = $(sqlExpEmbed "sqlfoobar.sql") -- using foo and bar inside mpostgresql-query Just like l0 but uses pattern instead of file name. So, code $let query = $(sqlExpFile "foo/bar") is just the same as let query = $(sqlExpEmbed "sqlfoo bar.sql") "This function inspired by Yesod's  widgetFilekpostgresql-queryExpression of type Elpostgresql-query file pathpostgresql-queryExpression of type E abcdefghijklm gabcdefihjklm None" #$&'(-/2348>?' qpostgresql-queryDot-separated field name. Each element in nested list will be properly quoted and separated by dot. It also have instance of S and  so you can:let a = "hello" :: FNa FN ["hello"]let b = "user.name" :: FNbFN ["user","name"]let n = "u.name" :: FNrun $ toSqlBuilder n"\"u\".\"name\""("user" <> "name") :: FNFN ["user","name"]let a = "name" :: FNlet b = "email" :: FN9run [sqlExp|^{"u" <> a} = 'name', ^{"e" <> b} = 'email'|]4"\"u\".\"name\" = 'name', \"e\".\"email\" = 'email'"spostgresql-querytype to put and get from db inet and cidr typed postgresql fields. This should be in postgresql-simple in fact.vpostgresql-query?**postgresql-queryEntity with it's idpostgresql-queryAuxiliary typeclass for data types which can map to rows of some table. This typeclass is used inside functions like pgSelectEntities to generate queries.postgresql-queryId type for this entitypostgresql-queryTable name of this entitypostgresql-queryField names without  and created?. The order of field names must match with order of fields in ToRow and FromRow instances of this type. None" #$&'(-/2348>?/postgresql-queryOptions for deriving postgresql-query!Type name to table name converterpostgresql-query%Record field to column name converterpostgresql-queryTypeclasses to derive for Idpostgresql-queryBase type for Idpostgresql-queryDerives instance for  using type name and field names. Also generates type synonim for ID. E.g. code like this: data Agent = Agent { aName :: !Text , aAttributes :: !HStoreMap , aLongWeirdName :: !Int } deriving (Ord, Eq, Show) $(deriveEntity def { eoIdType = ''Id , eoTableName = textFN . toUnderscore' , eoColumnNames = textFN . toUnderscore' . drop 1 , eoDeriveClasses = [''Show, ''Read, ''Ord, ''Eq , ''FromField, ''ToField, ''PathPiece] } ''Agent ) Will generate code like this: instance Database.PostgreSQL.Query.Entity Agent where newtype EntityId Agent = AgentId {getAgentId :: Id} deriving (Show, Read, Ord, Eq, FromField, ToField, PathPiece) tableName _ = "agent" fieldNames _ = ["name", "attributes", "long_weird_name"] type AgentId = EntityId Agent 0So, you dont need to write it by hands any more.NOTE:  is from package  inflections here None" #$&'(-/2348>?4postgresql-queryCalls sequently _ ` . E.g. code like this: data Agent = Agent { aName :: !Text , aAttributes :: !HStoreMap , aLongWeirdName :: !Int } deriving (Ord, Eq, Show) $(deriveEverything def { eoIdType = ''Id , eoTableName = textFN . toUnderscore' , eoColumnNames = textFN . toUnderscore' . drop 1 , eoDeriveClasses = [''Show, ''Read, ''Ord, ''Eq , ''FromField, ''ToField, ''PathPiece] } ''Agent ) will generate that: instance ToRow Agent where toRow (Agent a_aE3w a_aE3x a_aE3y) = [toField a_aE3w, toField a_aE3x, toField a_aE3y] instance FromRow Agent where fromRow = Agent  $2 Database.PostgreSQL.Simple.FromRow.field  *2 Database.PostgreSQL.Simple.FromRow.field  * Database.PostgreSQL.Simple.FromRow.field instance Database.PostgreSQL.Query.Entity Agent where newtype EntityId Agent = AgentId {getAgentId :: Id} deriving (Show, Read, Ord, Eq, FromField, ToField, PathPiece) tableName _ = "agent" fieldNames _ = ["name", "attributes", "long_weird_name"] type AgentId = EntityId Agent ]^_`afedbcghijklm None" #$&'(-/2348>?8postgresql-query-Generates comma separated list of field namesrun $ buildFields ["u" <> "name", "u" <> "phone", "e" <> "email"]2"\"u\".\"name\", \"u\".\"phone\", \"e\".\"email\""postgresql-query generates UPDATE querylet name = "%vip%"run $ updateTable "ships" (MR [("size", mkValue 15)]) [sqlExp|WHERE size > 15 AND name NOT LIKE #{name}|]"UPDATE \"ships\" SET \"size\" = 15 WHERE size > 15 AND name NOT LIKE '%vip%'"postgresql-query%Generate INSERT INTO query for entityrun $ insertInto "foo" $ MR [("name", mkValue "vovka"), ("hobby", mkValue "president")]"INSERT INTO \"foo\" (\"name\", \"hobby\") VALUES ('vovka', 'president')"postgresql-query table namepostgresql-queryfields to updatepostgresql-query conditionpostgresql-query table namepostgresql-query*list of pairs (name, value) to insert intoNone" #$&'(-/2348>?Bpostgresql-queryExecute query generated by E. Typical use case: let userName = "Vovka Erohin" :: Text pgQuery [sqlExp| SELECT id, name FROM users WHERE name = #{userName}|] Or let userName = "Vovka Erohin" :: Text pgQuery $ Qp "SELECT id, name FROM users WHERE name = ?" [userName] Which is almost the same. In both cases proper value escaping is performed so you stay protected from sql injections.postgresql-query9Execute arbitrary query and return count of affected rowspostgresql-queryExecute all queries inside one transaction. Rollback transaction on exceptionspostgresql-querySame as & but executes queries inside savepointpostgresql-query Wrapper for : Execute an action inside a SQL transaction with a given transaction mode.postgresql-query Wrapper for : Like , but also takes a custom callback to determine if a transaction should be retried if an SqlError occurs. If the callback returns True, then the transaction will be retried. If the callback returns False, or an exception other than an SqlError occurs then the transaction will be rolled back and the exception rethrown.postgresql-query Wrapper for !: Execute an action inside of a  transaction. If a serialization failure occurs, roll back the transaction and try again. Be warned that this may execute the IO action multiple times.A Serializable transaction creates the illusion that your program has exclusive access to the database. This means that, even in a concurrent setting, you can perform queries in sequence without having to worry about what might happen between one statement and the next.postgresql-queryPerform repsert of the same row, first trying "update where" then "insert" with concatenated fields. Which means that if you run pgRepsertRow "emails" (MR [("user_id", mkValue uid)]) (MR [("email", mkValue email)]) Then firstly will be performed UPDATE "emails" SET email = 'foo@bar.com' WHERE "user_id" = 1234 4And if no one row is affected (which is returned by ), then INSERT INTO "emails" ("user_id", "email") VALUES (1234, 'foo@bar.com') will be performedpostgresql-query Table namepostgresql-querywhere conditionpostgresql-query update row  None" #$&'(-/2348>?Spostgresql-queryBuild entity fields.data Foo = Foo { fName :: Text, fSize :: Int }instance Entity Foo where {newtype EntityId Foo = FooId Int ; fieldNames _ = ["name", "size"] ; tableName _ = "foo"}-run $ entityFields id id (Proxy :: Proxy Foo)"\"name\", \"size\""2run $ entityFields ("id":) id (Proxy :: Proxy Foo)"\"id\", \"name\", \"size\""run $ entityFields (\l -> ("id":l) ++ ["created"]) id (Proxy :: Proxy Foo))"\"id\", \"name\", \"size\", \"created\""2run $ entityFields id ("f"<>) (Proxy :: Proxy Foo) "\"f\".\"name\", \"f\".\"size\""9run $ entityFields ("f.id":) ("f"<>) (Proxy :: Proxy Foo)."\"f\".\"id\", \"f\".\"name\", \"f\".\"size\""postgresql-querySame as ! but prefixes list of names with id3 field. This is shorthand function for often usage..data Foo = Foo { fName :: Text, fSize :: Int }instance Entity Foo where {newtype EntityId Foo = FooId Int ; fieldNames _ = ["name", "size"] ; tableName _ = "foo"},run $ entityFieldsId id (Proxy :: Proxy Foo)"\"id\", \"name\", \"size\""1run $ entityFieldsId ("f"<>) (Proxy :: Proxy Foo)."\"f\".\"id\", \"f\".\"name\", \"f\".\"size\""postgresql-query'Generate SELECT query string for entity.data Foo = Foo { fName :: Text, fSize :: Int }instance Entity Foo where {newtype EntityId Foo = FooId Int ; fieldNames _ = ["name", "size"] ; tableName _ = "foo"};run $ selectEntity (entityFieldsId id) (Proxy :: Proxy Foo)0"SELECT \"id\", \"name\", \"size\" FROM \"foo\""run $ selectEntity (entityFieldsId ("f"<>)) (Proxy :: Proxy Foo)"SELECT \"f\".\"id\", \"f\".\"name\", \"f\".\"size\" FROM \"foo\""). Applied firstpostgresql-querybuild fields part from proxyNone" #$&'(-/2348>?^ postgresql-query$Insert new entity and return it's idpostgresql-query)Select entities as pairs of (id, entity). handler :: Handler [Ent a] handler = do now <- liftIO getCurrentTime let back = addUTCTime (days (-7)) now pgSelectEntities id [sqlExp|WHERE created BETWEEN #{now} AND #{back} ORDER BY created|] handler2 :: Text -> Handler [Ent Foo] handler2 fvalue = do pgSelectEntities ("t"<>) [sqlExp|AS t INNER JOIN table2 AS t2 ON t.t2_id = t2.id WHERE t.field = #{fvalue} ORDER BY t2.field2|] -- Here the query will be: SELECT ... FROM tbl AS t INNER JOIN ... postgresql-querySame as  but do not select idpostgresql-query)Select entities by condition formed from  . Usefull function when you knowpostgresql-querySelect entity by id getUser :: EntityId User -> Handler User getUser uid = do pgGetEntity uid >>= maybe notFound return postgresql-query$Get entity by some fields constraint getUser :: UserName -> Handler User getUser name = do pgGetEntityBy (MR [("name", mkValue name), ("active", mkValue True)]) >>= maybe notFound return The query here will be like pgQuery [sqlExp|SELECT id, name, phone ... FROM users WHERE name = {name} AND active =  {True}|] postgresql-querySame as  but insert many entities at one action. Returns list of id's of inserted entitiespostgresql-query8Insert many entities without returning list of id like  doespostgresql-queryDelete entity. rmUser :: EntityId User -> Handler () rmUser uid = do pgDeleteEntity uid Return  if row was actually deleted.postgresql-queryUpdate entity using  instanced value. Requires  while  is not a data type. fixUser :: Text -> EntityId User -> Handler () fixUser username uid = do pgGetEntity uid >>= maybe notFound run where run user = pgUpdateEntity uid $ MR [("active", mkValue True) ("name", mkValue username)] Returns $ if record was actually updated and  if there was not row with such id (or was more than 1, in fact)postgresql-query)Select count of entities with given query activeUsers :: Handler Integer activeUsers = do pgSelectCount (Proxy :: Proxy User) [sqlExp|WHERE active = #{True}|] Executes arbitrary query and parses it as entities and their idspostgresql-queryEntity fields name modifier, e.g. ("tablename"<>). Each field of entity will be processed by this modifier before pasting to the querypostgresql-querypart of query just after SELECT .. FROM table.postgresql-query*uniq constrained list of fields and values  None" #$&'(-/2348>?_!None" #$&'(-/2348>?_  ! $#%"('&*)-,+/.1023456789ABCEFGHIJKLMNST]^_`afedbcghijklmqrstuvw2! %"$#('&*)10/.-,+    !"#$%&'(()**+,-+./0/1/2/3/4/5/6/7/8/9/9:;<=<>:?@A@B@B@C@C@D@E@E@F@F@G@GHIJKKLMNOPQRSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                           +.postgresql-query-3.10.0-5LISmCzCf6YHFrJlgDAYDlDatabase.PostgreSQL.Query*Database.PostgreSQL.Query.SqlBuilder.Types,Database.PostgreSQL.Query.SqlBuilder.Builder*Database.PostgreSQL.Query.SqlBuilder.Class#Database.PostgreSQL.Query.TH.Common!Database.PostgreSQL.Query.TH.Enum Database.PostgreSQL.Query.TH.Row#Database.PostgreSQL.Query.TH.SqlExpDatabase.PostgreSQL.Query.Types&Database.PostgreSQL.Query.Entity.Class#Database.PostgreSQL.Query.TH.EntityDatabase.PostgreSQL.Query.TH"Database.PostgreSQL.Query.Internal#Database.PostgreSQL.Query.Functions)Database.PostgreSQL.Query.Entity.Internal*Database.PostgreSQL.Query.Entity.Functions Database.PostgreSQL.Query.Import$Database.PostgreSQL.Query.SqlBuilder Database.PostgreSQL.Query.EntityOnly-0.1-Hmiu2AVa9qJ6EI7MrgJvvlData.Tuple.OnlyfromOnlyOnly/postgresql-libpq-0.9.4.3-7GMLDUbXM30H6jI5ad7aT4Database.PostgreSQL.LibPQOid.postgresql-simple-0.6.4-B9EavoqM35EKiPmjF8hek0"Database.PostgreSQL.Simple.FromRowfromRow0Database.PostgreSQL.Simple.HStore.ImplementationparseHStoreListhstoretoHStoreToHStore HStoreBuilder toHStoreText ToHStoreText HStoreTextfromHStoreList HStoreList fromHStoreMap HStoreMap$Database.PostgreSQL.Simple.FromField fromFieldFromRow FromField#Database.PostgreSQL.Simple.InternalconnectPostgreSQLconnectdefaultConnectInfo ConnectionconnectDatabaseconnectPassword connectUser connectPort connectHost ConnectInfo"Database.PostgreSQL.Simple.ToFieldtoField Database.PostgreSQL.Simple.ToRowtoRowToRowToField Database.PostgreSQL.Simple.Types fromQueryQueryIn fromPGArrayPGArray:.Values FieldOption FieldDefault FieldMaskedSqlBuilderResult sbQueryString sbLogStringbuilderResultPure$fMonoidSqlBuilderResult$fSemigroupSqlBuilderResult$fEqFieldOption$fOrdFieldOption$fShowFieldOption$fGenericFieldOption$fGenericSqlBuilderResult LogMaskerdefaultLogMaskerhugeFieldsMasker$fLiftLiftedRepFieldOption SqlBuildersqlBuild runSqlBuilderemptyBmkValue mkMaskedValuesqlBuilderFromFieldsqlBuilderPuresqlBuilderFromByteString$fIsStringSqlBuilder$fMonoidSqlBuilder$fSemigroupSqlBuilder$fGenericSqlBuilder ToSqlBuilder toSqlBuilder!$fToSqlBuilderQualifiedIdentifier$fToSqlBuilderIdentifier$fToSqlBuilderSqlBuildercNamecArgs cFieldNameslookupVNameErrdataConstructors InflectorFunc derivePgEnum deriveFromRow deriveToRowRopeRLitRCommentRSpacesRIntRPastesqlExp parseRope ropeParser squashRopesqlQExp sqlExpEmbed sqlExpFile $fOrdRope$fEqRope $fShowRopeFNInetText unInetTextQp$fToSqlBuilderQp$fFromFieldInetText$fOrdFN$fEqFN$fShowFN $fSemigroupFN $fMonoidFN $fGenericFN$fIsStringInetText $fEqInetText $fOrdInetText$fReadInetText$fShowInetText$fSemigroupInetText$fMonoidInetText$fToFieldInetTextPgMonadT unPgMonadTTransactionSafe HasPostgreswithPGConnection MonadPostgres ToMarkedRow toMarkedRow MarkedRowMRunMRtextFN mrToBuilder runPgMonadTlaunchPG $fIsStringFN$fToSqlBuilderFN$fLiftLiftedRepFN$fToMarkedRowMarkedRow$fHasPostgresHReaderT$fHasPostgresWriterT$fHasPostgresWriterT0$fHasPostgresContT$fHasPostgresStateT$fHasPostgresStateT0$fHasPostgresReaderT$fHasPostgresMaybeT$fHasPostgresIdentityT$fHasPostgresExceptT$fTransactionSafeWriterT$fTransactionSafeWriterT0$fTransactionSafeContT$fTransactionSafeStateT$fTransactionSafeStateT0$fTransactionSafeReaderT$fTransactionSafeMaybeT$fTransactionSafeIdentityT$fTransactionSafeExceptT$fTransactionSafePgMonadT$fHasPostgresPgMonadT$fMonadHReaderPgMonadT$fMonadReaderrPgMonadT$fMonadTransControlPgMonadT$fMonadBaseControlbPgMonadT$fFunctorPgMonadT$fApplicativePgMonadT$fMonadPgMonadT$fMonadWriterwPgMonadT$fMonadStatesPgMonadT$fMonadErrorePgMonadT$fMonadTransPgMonadT$fAlternativePgMonadT$fMonadFixPgMonadT$fMonadPlusPgMonadT$fMonadIOPgMonadT$fMonadContPgMonadT$fMonadThrowPgMonadT$fMonadCatchPgMonadT$fMonadMaskPgMonadT$fMonadBasebPgMonadT$fMonadLoggerPgMonadT$fMonadFailPgMonadT$fSemigroupMarkedRow$fMonoidMarkedRow$fGenericMarkedRowEntEntityEntityId tableName fieldNames EntityOptions eoTableName eoColumnNameseoDeriveClasseseoIdType deriveEntity$fDefaultEntityOptions$fGenericEntityOptionsderiveEverything buildFields updateTable insertIntopgQuery pgExecutepgQueryWithMaskerpgExecuteWithMaskerpgWithTransactionpgWithSavepointpgWithTransactionModepgWithTransactionModeRetrypgWithTransactionSerializable pgRepsertRow entityFieldsentityFieldsId selectEntityselectEntitiesBy entityToMR insertEntityinsertManyEntitiespgInsertEntitypgSelectEntitiespgSelectJustEntitiespgSelectEntitiesBy pgGetEntity pgGetEntityBypgInsertManyEntitiesIdpgInsertManyEntitiespgDeleteEntitypgUpdateEntitypgQueryEntities pgSelectCountbase Control.MonadguardGHC.Stack.TypesemptyCallStack pushCallStackGHC.BasejoinMonadreturn>>=>>Functorfmap<$Data.Typeable.InternalTypeableControl.Monad.Fail MonadFailfail Data.StringIsString fromString ApplicativeliftA2<**>pure<*>Data.TraversablemapMsequence GHC.GenericsGeneric Semigroupstimes<>sconcat GHC.MaybeMaybeNothingJustghc-prim GHC.TypesType Constraint CallStackTyConString Data.Functor<$> text-1.2.3.2Data.Text.InternalText Data.FoldableforM_mapM_ Alternativesomemanyempty<|> MonadPlusmzeromplusData.Semigroupoption mtimesDefaultdiffcycle1MingetMinMaxgetMaxArgArgMinArgMaxFirstgetFirstLastgetLast WrappedMonoid WrapMonoid unwrapMonoidOption getOptionmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforMControl.Applicativeoptional WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipList GHC.StackwithFrozenCallStack callStack popCallStackerrorWithStackTrace GHC.Stack.CCS renderStack whoCreated ccsToStrings ccSrcSpanccModuleccLabel ccsParentccsCCclearCCSgetCCSOf getCurrentCCSCostCentreStack CostCentre GHC.ExceptionprettyCallStack prettySrcLocGHC.Exception.Type ExceptiondisplayException toException fromException Data.TypeabletypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfTypeReprnfTyContyConFingerprint tyConName tyConModule tyConPackageData.Functor.ConstConstgetConstmsum sequence_Data.Semigroup.Internal stimesMonoidstimesIdempotentDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProduct Data.OldListunwordswordsunlineslines Data.Proxy asProxyTypeOfProxyKProxyData.Type.Equality:~:Refl:~~:HRefl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybevoidcurrentCallStackapliftM5liftM4liftM3liftM2liftMwhen=<<liftA3liftA<**>NonEmptyfreezeCallStackfromCallSiteList getCallStack HasCallStackSrcLoc srcLocEndCol srcLocEndLinesrcLocStartColsrcLocStartLine srcLocFile srcLocPackage srcLocModulestimesIdempotentMonoid SomeExceptionexceptions-0.10.4Control.Monad.Catch MonadThrowthrowMbracketOnErrorfinallybracket_bracketonError onExceptioncatchestryJusttry handleJusthandleIf handleAll handleIOErrorhandle catchJustcatchIf catchIOErrorcatchAlluninterruptibleMask_mask_ MonadCatchcatch MonadMaskgeneralBracketmaskuninterruptibleMaskExitCase ExitCaseAbortExitCaseSuccessExitCaseExceptionHandler(fast-logger-3.1.1-1ccwz4fwoMVJZqUSJ0SOZQSystem.Log.FastLogger.LogStr fromLogStrLogStrToLogStrtoLogStr,monad-control-1.0.3.1-BKTtuIuJ2972Ciy63qt9uZControl.Monad.Trans.Control liftBaseOp_.transformers-base-0.4.6-9l1zkBpf6nPFSscDpJZlweControl.Monad.Base MonadBaseliftBase liftThroughliftBaseOpDiscardliftBaseDiscard liftBaseOpcaptureMcaptureTembed_embedcontrolTcontroldefaultRestoreMdefaultLiftBaseWithdefaultRestoreT2defaultLiftWith2defaultRestoreTdefaultLiftWithStTMonadTransControlrestoreTliftWithRun RunDefault RunDefault2StMMonadBaseControlrestoreM liftBaseWith RunInBase ComposeStRunInBaseDefault*monad-logger-0.3.36-5SHRYIGwznMK0jqcpNTyeFControl.Monad.Logger.CallStack logOtherSH logErrorSH logWarnSH logInfoSH logDebugSHlogOtherlogErrorlogWarnlogInfologDebugControl.Monad.Logger logOtherCS logErrorCS logWarnCS logInfoCS logDebugCS logOtherNS logErrorNS logWarnNS logInfoNS logDebugNS logOtherN logErrorNlogWarnNlogInfoN logDebugN logWithoutLoc defaultLoc mapNoLoggingT mapLoggingT filterLoggerwithChannelLoggerunChanLoggingTrunChanLoggingTrunStdoutLoggingTrunStderrLoggingTrunFileLoggingT defaultLogStr defaultOutputexecWriterLoggingTrunWriterLoggingT logOtherS logErrorSlogWarnSlogInfoS logDebugSliftLocLogLevel LevelOther LevelError LevelWarn LevelDebug LevelInfo LogSource MonadLoggermonadLoggerLog MonadLoggerIO askLoggerIO NoLoggingT runNoLoggingTLogLineWriterLoggingTunWriterLoggingTLoggingT runLoggingTtemplate-haskellLanguage.Haskell.TH.SyntaxLoc loc_filename loc_package loc_moduleloc_end loc_startliftBaseDefaultmemptynameid*inflections-0.4.0.6-Gj0yNtnvLZp5PZ9l2tiWfEText.Inflections toUnderscore&Database.PostgreSQL.Simple.TransactionwithTransactionModewithTransactionModeRetrywithTransactionSerializable SerializableTrueFalse