!J$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde f g h i j k l m n o p q r s t u v w x y z { | } ~                                   ! " # $ % & ' ( ) * + , - . / 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 [\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!(c) 2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalSafe%UV?!postgresql-simpleDParse one of three primitive field formats: array, quoted and plain.#postgresql-simpleRecognizes a quoted string.$postgresql-simplesRecognizes a plain string literal, not containing quotes or brackets and not containing the delimiter character.%postgresql-simple]Format an array format item, using the delimiter character if the item is itself an array.&postgresql-simpleFormat a list of array format items, inserting the appropriate delimiter between them. When the items are arrays, they will be delimited with commas; otherwise, they are delimited with the passed-in-delimiter.'postgresql-simpleFormat an array format item, using the delimiter character if the item is itself an array, optionally applying quoting rules. Creates copies for safety when used in  FromField instances.(postgresql-simpleBEscape a string according to Postgres double-quoted string format.  !"#$%&'( ! "#$%&'(None%UVFpostgresql-simpleLike ., but backported to base before version 4.3.0.9Note that the restore callback is monomorphic, unlike in {. This could be fixed by changing the type signature, but it would require us to enable the RankNTypes extension (since  has a rank-3 type). The withTransactionModeT function calls the restore callback only once, so we don't need that polymorphism.(c) 2012-2015 Leon P SmithBSD3leon@melding-monads.com experimentalSafe%24UVK',postgresql-simple;a way to reify a list of exceptions into a single exception6postgresql-simpleTwo /U cases are considered equal, regardless of what the list of exceptions looks like.,-.0/.0/,-B(c) 2012-2015 Leon P Smith (c) 2015 Bryan O'SullivanBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVX` postgresql-simpleParse a date of the form  YYYY-MM-DD.postgresql-simple4Parse a two-digit integer (e.g. day of month, hour).postgresql-simpleParse a time of the form HH:MM[:SS[.SSS]].postgresql-simpleGParse a count of seconds, with the integer part being two digits long.postgresql-simpleParse a time zone, and return F if the offset from UTC is zero. (This makes some speedups possible.)postgresql-simpleParse a time zone, and return F if the offset from UTC is zero. (This makes some speedups possible.)postgresql-simple#Parse a date and time, of the form YYYY-MM-DD HH:MM:SS$. The space may be replaced with a TD. The number of seconds may be followed by a fractional component.postgresql-simple Behaves as 5, but converts any time zone offset into a UTC time.postgresql-simple5Parse a date with time zone info. Acceptable formats: YYYY-MM-DD HH:MM:SS Z!The first space may instead be a T*, and the second space is optional. The Z represents UTC. The Z6 may be replaced with a time zone offset of the form +0000 or -08:00-, where the first two digits are hours, the :D is optional and the second two digits (also optional) are minutes. None%UV`(c) 2012-2015 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%24UVbr+;<=>?@BACDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd(c) 2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVd ;MNOPQRSTUVWX MNOPQRUVWX;ST(c) 2012-2015 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVf<=>?@CABDEFGHIJKLYZ[\]^_`abcd@CAB<>=?GDEFHLIJKY\]^Z[c`ab_d(c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVkNipostgresql-simpleeA structure representing some of the metadata regarding a PostgreSQL type, mostly taken from the pg_type table.efhgimjlkutsrqpon (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVm5ikljmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZikljmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ@(c) 2011 MailRank, Inc. (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone %24MUV~ [postgresql-simple Represents a VALUES0 table literal, usable as an alternative to   and !M. The main advantage is that you can parametrize more than just a single VALUES expression. For example, here's a query to insert a thing into one table and some attributes of that thing into another, returning the new id generated by the database: query c [sql| WITH new_thing AS ( INSERT INTO thing (name) VALUES (?) RETURNING id ), new_attributes AS ( INSERT INTO thing_attributes SELECT new_thing.id, attrs.* FROM new_thing JOIN ? attrs ON TRUE ) SELECT * FROM new_thing |] ("foo", Values [ "int4", "text" ] [ ( 1 , "hello" ) , ( 2 , "world" ) ])b(Note this example uses writable common table expressions, which were added in PostgreSQL 9.1)AThe second parameter gets expanded into the following SQL syntax: 0(VALUES (1::"int4",'hello'::"text"),(2,'world'))GWhen the list of attributes is empty, the second parameter expands to: ,(VALUES (null::"int4",null::"text") LIMIT 0) By contrast,  executeMany and  returning? don't issue the query in the empty case, and simply return 0 and [] respectively. This behavior is usually correct given their intended use cases, but would certainly be wrong in the example above.The first argument is a list of postgresql type names. Because this is turned into a properly quoted identifier, the type name is case sensitive and must be as it appears in the pg_type" table. Thus, you must write  timestamptz instead of timestamp with time zone, int4 instead of integer or serial, _int8 instead of bigint[], etcetera.You may omit the type names, however, if you do so the list of values must be non-empty, and postgresql must be able to infer the types of the columns from the surrounding context. If the first condition is not met, postgresql-simple will throw an exception without issuing the query. In the second case, the postgres server will return an error which will be turned into a SqlError exception.See  :https://www.postgresql.org/docs/9.5/static/sql-values.html for more information._postgresql-simplerA composite type to parse your custom data structures without having to define dummy newtype wrappers every time. !instance FromRow MyData where ... "instance FromRow MyData2 where ...%then I can do the following for free: Kres <- query' c "..." forM res $ \(MyData{..} :. MyData2{..}) -> do .... apostgresql-simple*Wrap a list for use as a PostgreSQL array.dpostgresql-simplecWrap text for use as (maybe) qualified identifier, i.e. a table with schema, or column with table.fpostgresql-simpleAWrap text for use as sql identifier, i.e. a table or column name.ipostgresql-simpleWrap binary data for use as a bytea value.lpostgresql-simple$Wrap a list of values for use in an IN clause. Replaces a single "?:" character with a parenthesized list of rendered values.Example: Bquery c "select * from whatever where id in ?" (Only (In [3,4,5])) Note that In [] expands to (null)p, which works as expected in the query above, but evaluates to the logical null value on every row instead of TRUE0. This means that changing the query above to ... id NOT in ?n and supplying the empty list as the parameter returns zero rows, instead of all of them as one would expect.Since postgresql doesn't seem to provide a syntax for actually specifying an empty list, which could solve this completely, there are two workarounds particularly worth mentioning, namely: Use postgresql-simple's [} type instead, which can handle the empty case correctly. Note however that while specifying the postgresql type "int4"C is mandatory in the empty case, specifying the haskell type Values (Only Int): would not normally be needed in realistic use cases. kquery c "select * from whatever where id not in ?" (Only (Values ["int4"] [] :: Values (Only Int))) Use sql's COALESCE operator to turn a logical nulld into the correct boolean. Note however that the correct boolean depends on the use case: equery c "select * from whatever where coalesce(id NOT in ?, TRUE)" (Only (In [] :: In [Int])) bquery c "select * from whatever where coalesce(id IN ?, FALSE)" (Only (In [] :: In [Int]))LNote that at as of PostgreSQL 9.4, the query planner cannot see inside the COALESCE' operator, so if you have an index on id= then you probably don't want to write the last example with COALESCEF, which would result in a table scan. There are further caveats if idA can be null or you want null treated sensibly as a component of IN or NOT IN.npostgresql-simpleA query string. This type is intended to make it difficult to construct a SQL query by concatenating string fragments, as that is an extremely common way to accidentally introduce SQL injection vulnerabilities into an application.This type is an instance of <, so the easiest way to construct a query is to enable the OverloadedStringsF language extension and then simply write the query in double quotes. `{-# LANGUAGE OverloadedStrings #-} import Database.PostgreSQL.Simple q :: Query q = "select ?"The underlying type is a g, and literal Haskell strings that contain Unicode characters will be correctly transformed to UTF-8.qpostgresql-simple!A placeholder for the PostgreSQL DEFAULT value.spostgresql-simpleA placeholder for the SQL NULL value.|postgresql-simple "foo.bar" will get turned into &QualifiedIdentifier (Just "foo") "bar" , while "foo" will get turned into !QualifiedIdentifier Nothing "foo". Note this instance is for convenience, and does not match postgres syntax. It only examines the first period character, and thus cannot be used if the qualifying identifier contains a period for example.[\]^_`abcdefghijklmnopqrststqrlmijkfghdenop_`]^abc[\_3`3 (c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVpostgresql-simple$Returns an expression that has type  -> 1, true if the oid is equal to any one of the ns of the given is.postgresql-simpleLiterally substitute the n of a i. expression. Returns an expression of type 5. Useful because GHC tends not to fold constants. @(c) 2011 MailRank, Inc. (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone %24=?UV postgresql-simple=A type that may be used as a single parameter to a SQL query.postgresql-simple;How to render an element when substituting it into a query.postgresql-simpleZRender without escaping or quoting. Use for non-text types such as numbers, when you are certaind that they will not introduce formatting vulnerabilities via use of characters such as spaces or "'".postgresql-simpleEscape and enclose in quotes before substituting. Use for all text-like types, and anything else that may contain unsafe characters when rendered.postgresql-simple Escape binary data for use as a bytea= literal. Include surrounding quotes. This is used by the i newtype wrapper.postgresql-simplelEscape before substituting. Use for all sql identifiers like table, column names, etc. This is used by the f newtype wrapper.postgresql-simple*Concatenate a series of rendering actions.postgresql-simple5Prepare a value for substitution into a query string.postgresql-simple"Convert a Haskell value to a JSON  using # and convert that to a field using .7This can be used as the default implementation for the J method for Haskell types that have a JSON representation in PostgreSQL.postgresql-simple1Surround a string with single-quote characters: "'"This function does not perform any other escaping.postgresql-simplecitextpostgresql-simplecitext   @(c) 2011 MailRank, Inc. (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone %8=>?UVpostgresql-simple?A collection type that can be turned into a list of rendering s.Instances should use the  method of the @ class to perform conversion of each element of the collection.You can derive 2 for your data type using GHC generics, like this: H{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} import  GHC.Generics ( ) import Database.PostgreSQL.Simple (E) data User = User { name :: String, fileQuota :: Int } deriving (, ) nNote that this only works for product types (e.g. records) and does not support sum types or recursive types.(c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVpostgresql-simplev is a quasiquoter that eases the syntactic burden of writing big sql statements in Haskell source code. For example: O{-# LANGUAGE QuasiQuotes #-} query conn [sql| SELECT column_a, column_b FROM table1 NATURAL JOIN table2 WHERE ? <= time AND time < ? AND name LIKE ? ORDER BY size DESC LIMIT 100 |] (beginTime,endTime,string)=This quasiquoter returns a literal string expression of type n, and attempts to mimimize whitespace; otherwise the above query would consist of approximately half whitespace when sent to the database backend. It also recognizes and strips out standard sql comments "--".The implementation of the whitespace reducer is currently incomplete. Thus it can mess up your syntax in cases where whitespace should be preserved as-is. It does preserve whitespace inside standard SQL string literals. But it can get confused by the non-standard PostgreSQL string literal syntax (which is the default setting in PostgreSQL 8 and below), the extended escape string syntax, quoted identifiers, and other similar constructs.Of course, this caveat only applies to text written inside the SQL quasiquoter; whitespace reduction is a compile-time computation and thus will not touch the string. parameter above, which is a run-time value.3Also note that this will not work if the substring |] is contained in the query.(c) 2011-2015 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone "#%27MUVj postgresql-simpleException thrown if a nE could not be formatted correctly. This may occur if the number of '?S' characters in the query string does not match the number of parameters provided.postgresql-simpleException thrown if query is used to perform an INSERT-like operation, or execute is used to perform a SELECT-like operation.)postgresql-simple4A Field represents metadata about a particular fieldYou don't particularly want to retain these structures for a long period of time, as they will retain the entire query result, not just the field metadata-postgresql-simpleOThis returns the type oid associated with the column. Analogous to libpq's PQftype./postgresql-simple0Default information for setting up a connection.Defaults are as follows: Server on  localhostPort on 5432User postgres No password Database postgres Use as in the following example: =connect defaultConnectInfo { connectHost = "db.example.com" }0postgresql-simplegConnect with the given username to the given database. Will throw an exception if it cannot connect.1postgresql-simpleHAttempt to make a connection based on a libpq connection string. See  Nhttps://www.postgresql.org/docs/9.5/static/libpq-connect.html#LIBPQ-CONNSTRING for more information. Also note that environment variables also affect parameters not provided, parameters provided as the empty string, and a few other things; see  <https://www.postgresql.org/docs/9.5/static/libpq-envars.htmlW for details. Here is an example with some of the most commonly used parameters: &host='db.somedomain.com' port=5432 ...This attempts to connect to db.somedomain.com:54326. Omitting the port will normally default to 5432.On systems that provide unix domain sockets, omitting the host parameter will cause libpq to attempt to connect via unix domain sockets. The default filesystem path to the socket is constructed from the port number and the DEFAULT_PGSOCKET_DIR constant defined in the pg_config_manual.h? header file. Connecting via unix sockets tends to use the peerP authentication method, which is very secure and does not require a password._On Windows and other systems without unix domain sockets, omitting the host will default to  localhost. @... dbname='postgres' user='postgres' password='secret \' \\ pw'-This attempts to connect to a database named postgres with user postgres and password  secret ' \ pwm. Backslash characters will have to be double-quoted in literal Haskell strings, of course. Omitting dbname and userS will both default to the system username that the client process is running as. Omitting password9 will default to an appropriate password found in the pgpassS file, or no password at all if a matching line is not found. The path of the pgpass) file may be specified by setting the  PGPASSFILE environment variable. See  <https://www.postgresql.org/docs/9.5/static/libpq-pgpass.html- for more information regarding this file.As all parameters are optional and the defaults are sensible, the empty connection string can be useful for development and exploratory use, assuming your system is set up appropriately.On Unix, such a setup would typically consist of a local postgresql server listening on port 5432, as well as a system user, database user, and database sharing a common name, with permissions granted to the user on the database..On Windows, in addition you will either need  pg_hba.conf to specify the use of the trust authentication method for the connection, which may not be appropriate for multiuser or production machines, or you will need to use a pgpass file with the password or md5 authentication methods.See  Ehttps://www.postgresql.org/docs/9.5/static/client-authentication.html> for more information regarding the authentication process.SSL/TLS will typically "just work" if your postgresql server supports or requires it. However, note that libpq is trivially vulnerable to a MITM attack without setting additional SSL connection parameters. In particular, sslmode needs to be set to require,  verify-ca, or  verify-full3 in order to perform certificate validation. When sslmode is require(, then you will also need to specify a  sslrootcert file, otherwise no validation of the server's identity will be performed. Client authentication via certificates is also possible via the sslcert and sslkey parameters. See  9https://www.postgresql.org/docs/9.5/static/libpq-ssl.html5 for detailed information regarding libpq and SSL.3postgresql-simpleTurns a  / data structure into a libpq connection string.6postgresql-simple A version of execute* that does not perform query substitution.:postgresql-simpleGAtomically perform an action with the database handle, if there is one.Gpostgresql-simpleQuote bytestring or throw Hpostgresql-simpleConnection for string escapingpostgresql-simpleQuery for message errorpostgresql-simple$List of parameters for message errorpostgresql-simpleAction to buildM     "! #$'&%()*,-+./0123456789:;<=>?@ABCDEFGHIJKLMNM)*,-+(#$'&%"! .  /0123456789:;<   =>?@ABCDEFGHIJKLMN>(c) 2011-2015 Leon P Smith (c) 2012 Joey AdamsBSD3leon@melding-monads.com experimentalNone "#$%UV{*kpostgresql-simpleGReturns a single notification. If no notifications are available, k blocks until one arrives.It is safe to call k on a connection that is concurrently being used for other purposes, note however that PostgreSQL does not deliver notifications while a connection is inside a transaction.lpostgresql-simpleNon-blocking variant of k`. Returns a single notification, if available. If no notifications are available, returns .mpostgresql-simpleReturns the process 9 of the backend server process handling this connection.The backend PID is useful for debugging purposes and for comparison to NOTIFY messages (which include the PID of the notifying backend process). Note that the PID belongs to a process executing on the database server host, not the local host!fghijklmfghijklm(c) 2011-2012 Leon P SmithBSD3leon@melding-monads.comNone%UV| pqrstuvwxyz{|pqrstuvwxyz{| ((c) 2012-2013 Leonid Onokhov, Joey AdamsBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone"#%2UVW~postgresql-simpleThe field is a column namepostgresql-simple*Table name and name of violated constraintpostgresql-simpleName of violated constraintpostgresql-simple.Relation name (usually table), constraint namepostgresql-simple*Name of the exclusion violation constraintpostgresql-simpleTries to convert  to ConstrainViolationC, checks sqlState and succeedes only if able to parse sqlErrorMsg. createUser = handleJust constraintViolation handler $ execute conn ... where handler (UniqueViolation "user_login_key") = ... handler _ = ...postgresql-simple;Like constraintViolation, but also packs original SqlError. createUser = handleJust constraintViolationE handler $ execute conn ... where handler (_, UniqueViolation "user_login_key") = ... handler (e, _) = throwIO epostgresql-simpleqCatches SqlError, tries to convert to ConstraintViolation, re-throws on fail. Provides alternative interface to  createUser = catchViolation catcher $ execute conn ... where catcher _ (UniqueViolation "user_login_key") = ... catcher e _ = throwIO e }~ }~<(c) 2011-2013 Leon P Smith (c) 2013 Joey AdamsBSD3&Leon P Smith <leon@melding-monads.com>None "#%UVXpostgresql-simpleIthe read-write mode will be taken from PostgreSQL's per-connection default_transaction_read_onlyi variable, which is initialized according to the server's config. The default configuration is .postgresql-simpleOf the four isolation levels defined by the SQL standard, these are the three levels distinguished by PostgreSQL as of version 9.0. See  ?https://www.postgresql.org/docs/9.5/static/transaction-iso.html= for more information. Note that prior to PostgreSQL 9.0,  was equivalent to .postgresql-simpleIthe isolation level will be taken from PostgreSQL's per-connection default_transaction_isolationi variable, which is initialized according to the server's config. The default configuration is .postgresql-simple+Execute an action inside a SQL transaction..This function initiates a transaction with a "begin transactionr" statement, then executes the supplied action. If the action succeeds, the transaction will be completed with "# before this function returns.If the action throws anyj kind of exception (not just a PostgreSQL-related exception), the transaction will be rolled back using &, then the exception will be rethrown.For nesting transactions, see .postgresql-simpleExecute 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  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. Think of it as STM, but without retry.postgresql-simpleHExecute an action inside a SQL transaction with a given isolation level.postgresql-simpleIExecute an action inside a SQL transaction with a given transaction mode.postgresql-simpleLike Z, but also takes a custom callback to determine if a transaction should be retried if an  occurs. If the callback returns True, then the transaction will be retried. If the callback returns False, or an exception other than an M occurs then the transaction will be rolled back and the exception rethrown.This is used to implement .postgresql-simpleRollback a transaction.postgresql-simple%Rollback a transaction, ignoring any IOErrorspostgresql-simpleCommit a transaction.postgresql-simpleBegin a transaction.postgresql-simple0Begin a transaction with a given isolation levelpostgresql-simple1Begin a transaction with a given transaction modepostgresql-simpleCreate a savepoint, and roll back to it if an error occurs. This may only be used inside of a transaction, and provides a sort of "nested transaction".See =https://www.postgresql.org/docs/9.5/static/sql-savepoint.htmlpostgresql-simpleGCreate a new savepoint. This may only be used inside of a transaction.postgresql-simple,Destroy a savepoint, but retain its effects.Warning: this will throw a  matching 2 if the transaction is aborted due to an error. " would merely warn and roll back.postgresql-simple?Roll back to a savepoint. This will not release the savepoint.postgresql-simple@Roll back to a savepoint and release it. This is like calling  followed by 2, but avoids a round trip to the database server.#]#] (c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone"#%UV(postgresql-simpleOReturns the metadata of the type with a particular oid. To find this data, 0 first consults postgresql-simple's built-in vU table, then checks the connection's typeinfo cache. Finally, the database's pg_typej table will be queried only if necessary, and the result will be stored in the connections's cache.efghikljmnopqrstuikljmnopqrstuefgh?(c) 2011 MailRank, Inc. (c) 2011-2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone"#%24=?UVX47postgresql-simple-A type that may be converted from a SQL type.postgresql-simple'Convert a SQL value to a Haskell value.yReturns a list of exceptions if the conversion fails. In the case of library instances, this will usually be a single , but may be a UnicodeException.)Note that retaining any reference to the ) argument causes the entire LibPQ., to be retained. Thus, implementations of e should return results that do not refer to this value after the result have been evaluated to WHNF.Note that as of postgresql-simple-0.4.0.0, the + value has already been copied out of the LibPQ. before it has been passed to b. This is because for short strings, it's cheaper to copy the string than to set up a finalizer.postgresql-simpleJException thrown if conversion from a SQL value to a Haskell value fails.postgresql-simple-The SQL and Haskell types are not compatible.postgresql-simpleA SQL NULL: was encountered when the Haskell type did not permit it.postgresql-simpleThe SQL value could not be parsed, or could not be represented as a valid Haskell value, or an unexpected low-level error occurred (e.g. mismatch between metadata and actual data in a row).postgresql-simpleReturns the data type name. This is the preferred way of identifying types that do not have a stable type oid, such as types provided by extensions to PostgreSQL.!More concretely, it returns the typname/ column associated with the type oid in the pg_type table. First, postgresql-simple will check the built-in, static table. If the type oid is not there, postgresql-simple will check a per-connection cache, and then finally query the database's meta-schema.postgresql-simplepReturns the name of the column. This is often determined by a table definition, but it can be set using an as clause.postgresql-simple)Returns the name of the object id of the table2 associated with the column, if any. Returns  when there is no such table; for example a computed column does not have a table associated with it. Analogous to libpq's PQftable.postgresql-simpleIf the column has a table associated with it, this returns the number off the associated table column. Numbering starts from 0. Analogous to libpq's  PQftablecol.postgresql-simplebThis returns whether the data was returned in a binary or textual format. Analogous to libpq's  PQfformat.postgresql-simpleFor dealing with SQL null values outside of the ( class. Alternatively, one could use $%:, but that also turns type and conversion errors into 3, whereas this is more specific and turns only null values into .postgresql-simple#Return the JSON ByteString directlypostgresql-simpleParse a field to a JSON 2 and convert that into a Haskell value using the  instance.7This can be used as the default implementation for the J method for Haskell types that have a JSON representation in PostgreSQL.The T constraint is required to show more informative error messages when parsing fails. Note that fromJSONField :: FieldParser ( Foo) will return  on the json null' value, and return an exception on SQL null* value. Alternatively, one could write  fromJSONField that will return Nothing on SQL null, and otherwise will call  fromJSONField :: FieldParser Foo and then return L the result value, or return its exception. If one would like to return Nothing on both the SQL null and json null. values, one way to do it would be to write  \f mv -> &' ! optionalField fromJSONField f mvpostgresql-simpleTeq and / are used to imlement what Macro stuff did, i.e. mkCompats and inlineTypoidpostgresql-simple#Given one of the constructors from , the field, and an v, this fills in the other fields in the exception value and returns it in a 'Left . SomeException' constructor.postgresql-simple)Compatible with the same set of types as a. Note that modifying the M does not have any effects outside the local process on the local machine.postgresql-simple)Compatible with the same set of types as a. Note that modifying the M does not have any effects outside the local process on the local machine.postgresql-simple json, jsonbpostgresql-simpleuuidpostgresql-simple=any postgresql array whose elements are compatible with type apostgresql-simple1Compatible with both types. Conversions to type b+ are preferred, the conversion to type a will be tried after the  conversion fails.postgresql-simpledatepostgresql-simple timestamppostgresql-simple timestamptzpostgresql-simple timestamptzpostgresql-simpletimepostgresql-simpledatepostgresql-simple timestamppostgresql-simple timestamptzpostgresql-simple timestamptzpostgresql-simple#name, text, "char", bpchar, varcharpostgresql-simplecitextpostgresql-simplecitextpostgresql-simple#name, text, "char", bpchar, varcharpostgresql-simple#name, text, "char", bpchar, varcharpostgresql-simplebyteapostgresql-simplebyteapostgresql-simple3bytea, name, text, "char", bpchar, varchar, unknownpostgresql-simpleoidpostgresql-simple3bytea, name, text, "char", bpchar, varchar, unknownpostgresql-simple)int2, int4, int8, float4, float8, numericpostgresql-simple)int2, int4, int8, float4, float8, numericpostgresql-simple/int2, int4, float4, float8 (Uses attoparsec's - routine, for better accuracy convert to  or  first)postgresql-simple#int2, float4 (Uses attoparsec's - routine, for better accuracy convert to  or  first)postgresql-simpleint2, int4, int8postgresql-simpleint2, int4, int8postgresql-simplefint2, int4, and if compiled as 64-bit code, int8 as well. This library was compiled as 64-bit code.postgresql-simple int2, int4postgresql-simpleint2postgresql-simple"char", bpcharpostgresql-simpleboolpostgresql-simple:compatible with any data type, but the value must be nullpostgresql-simple[For dealing with null values. Compatible with any postgresql type compatible with type au. Note that the type is not checked if the value is null, although it is inadvisable to rely on this behavior.postgresql-simplevoid3 efghikljmnopqrstu)-?@3?@)ikljmnopqrstuefgh- 2E(c) 2014-2015 Leonid Onokhov (c) 2014-2015 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com>None %24=?UVGpostgresql-simpleGeneric range typepostgresql-simpleRepresents boundary of a range postgresql-simple$Is a range empty? If this returns  , then the  ! predicate will always return !. However, if this returns D, it is not necessarily true that there exists a point for which   returns . Consider  (Excludes 2) (Excludes 3) :: PGRange Int, for example. postgresql-simpleDoes a range contain a given point? Note that in some cases, this may not correspond exactly with a server-side computation. Consider UTCTimeN for example, which has a resolution of a picosecond, whereas postgresql's  timestamptz types have a resolution of a microsecond. Putting such Haskell values into the database will result in them being rounded, which can change the value of the containment predicate.postgresql-simpleGeneric range parserpostgresql-simple!Simple double quoted value parserpostgresql-simple)Generic range to builder for plain values           (@(c) 2011 MailRank, Inc. (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVJ)(c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%2MUVP3postgresql-simpleFRepresents escape text, ready to be the key or value to a hstore value7postgresql-simpleRepresents valid hstore syntax.postgresql-simpleAssumed to be UTF-8 encodedpostgresql-simpleAssumed to be UTF-8 encodedpostgresql-simplehstorepostgresql-simplehstore-./0123456798:;<=>?@AB(c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVR34789@AB78934@AB(c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%UVTj-./0123567:;<=>?012-./:;7<=>?563(c) 2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone "#%8=>?UVi^postgresql-simpleA collection type that can be converted from a sequence of fields. Instances are provided for tuples up to 10 elements and lists of any length.Note that instances can be defined outside of postgresql-simple, which is often useful. For example, here's an instance for a user-defined pair: @data User = User { name :: String, fileQuota :: Int } instance # User where fromRow = User <$> E <*> E The number of calls to E_ must match the number of fields returned in a single row of the query result. Otherwise, a  exception will be thrown.You can also derive 3 for your data type using GHC generics, like this: H{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} import  GHC.Generics ( ) import Database.PostgreSQL.Simple (E) data User = User { name :: String, fileQuota :: Int } deriving (, ) nNote that this only works for product types (e.g. records) and does not support sum types or recursive types. Note that E evaluates its result to WHNF, so the caveats listed in mysql-simple and very early versions of postgresql-simple no longer apply. Instead, look at the caveats associated with user-defined implementations of .CDEFCEDFB(c) 2011-2012 Leon P Smith (c) 2017 Bardur ArantssonBSD3&Leon P Smith <leon@melding-monads.com>None%UVuxpostgresql-simpleCursor within a transaction.ypostgresql-simpleXDeclare a temporary cursor. The cursor is given a unique name for the given connection.zpostgresql-simpleClose the given cursor.{postgresql-simpleFold over a chunk of rows from the given cursor, calling the supplied fold-like function on each row as it is received. In case the cursor is exhausted, a ! value is returned, otherwise a  value is returned.|postgresql-simpleFold over a chunk of rows, calling the supplied fold-like function on each row as it is received. In case the cursor is exhausted, a  value is returned, otherwise a  value is returned.xyz{|xyz|{@(c) 2011 MailRank, Inc. (c) 2011-2012 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone "#$%2UVpostgresql-simpleExecute a multi-row INSERT, UPDATE=, or other SQL query that is not expected to return results.Returns the number of rows affected. If the list of parameters is empty, this function will simply return 0 without issuing the query to the backend. If this is not desired, consider using the Values constructor instead.Throws 6 if the query could not be formatted correctly, or a + exception if the backend returns an error.TFor example, here's a command that inserts two rows into a table with two columns: [executeMany c [sql| INSERT INTO sometable VALUES (?,?) |] [(1, "hello"),(2, "world")] :Here's an canonical example of a multi-row update command: executeMany c [sql| UPDATE sometable SET sometable.y = upd.y FROM (VALUES (?,?)) as upd(x,y) WHERE sometable.x = upd.x |] [(1, "hello"),(2, "world")] postgresql-simple Execute an INSERT, UPDATE=, or other SQL query that is not expected to return results.$Returns the number of rows affected.Throws 6 if the query could not be formatted correctly, or a + exception if the backend returns an error.postgresql-simple A version of * that does not perform query substitution.postgresql-simple Perform a SELECT or other SQL query that is expected to return results. All results are retrieved and converted before this function returns.hWhen processing large results, this function will consume a lot of client-side memory. Consider using  instead.Exceptions that may be thrown:4: the query string could not be formatted correctly.>: the result contains no columns (i.e. you should be using  instead of ).: result conversion failed.t: the postgresql backend returned an error, e.g. a syntax or type error, or an incorrect table or column name.postgresql-simple%Number of rows to fetch at a time.  currently defaults to 256 rows, although it might be nice to make this more intelligent based on e.g. the average size of the rows.postgresql-simpleFormat a query string.mThis function is exposed to help with debugging and logging. Do not use it to prepare queries for execution.LString parameters are escaped according to the character set in use on the #.Throws 7 if the query string could not be formatted correctly.postgresql-simple5Format a query string with a variable number of rows.mThis function is exposed to help with debugging and logging. Do not use it to prepare queries for execution.^The query string must contain exactly one substitution group, identified by the SQL keyword "VALUES&" (case insensitive) followed by an "(&" character, a series of one or more "?*" characters separated by commas, and a ")?" character. White space in a substitution group is permitted.Throws 7 if the query string could not be formatted correctly.postgresql-simpleExecute INSERT ... RETURNING, UPDATE ... RETURNING}, or other SQL query that accepts multi-row input and is expected to return results. Note that it is possible to write $ conn "INSERT ... RETURNING ..." ...c in cases where you are only inserting a single row, and do not need functionality analogous to .FIf the list of parameters is empty, this function will simply return []Z without issuing the query to the backend. If this is not desired, consider using the Values constructor instead.Throws / if the query could not be formatted correctly.postgresql-simple A version of  taking parser as argumentpostgresql-simple A version of  taking parser as argumentpostgresql-simple A version of  taking parser as argumentpostgresql-simple Perform a SELECT or other SQL query that is expected to return results. Results are streamed incrementally from the server, and consumed via a left fold.PWhen dealing with small results, it may be simpler (and perhaps faster) to use  instead. This fold is notk strict. The stream consumer is responsible for forcing the evaluation of its result to avoid space leaks.This is implemented using a database cursor. As such, this requires a transaction. This function will detect whether or not there is a transaction in progress, and will create a  n transaction if needed. The cursor is given a unique temporary name, so the consumer may itself call fold.Exceptions that may be thrown:4: the query string could not be formatted correctly.>: the result contains no columns (i.e. you should be using  instead of ).: result conversion failed.t: the postgresql backend returned an error, e.g. a syntax or type error, or an incorrect table or column name.postgresql-simple A version of  taking a parser as an argumentpostgresql-simple defaults to , and   postgresql-simple The same as ., but this provides a bit more control over lower-level details. Currently, the number of rows fetched per round-trip to the server and the transaction mode may be adjusted accordingly. If the connection is already in a transaction, then the existing transaction is used and thus the  option is ignored.postgresql-simple A version of  taking a parser as an argumentpostgresql-simple A version of * that does not perform query substitution.postgresql-simple A version of  taking a parser as an argumentpostgresql-simple A version of  taking a parser as an argumentpostgresql-simple A version of ' that does not transform a state value.postgresql-simple A version of  taking a parser as an argumentpostgresql-simple A version of * that does not perform query substitution.postgresql-simpleQuery.postgresql-simple"Initial state for result consumer.postgresql-simpleResult consumer.postgresql-simpleQuery.postgresql-simple"Initial state for result consumer.postgresql-simpleResult consumer.postgresql-simpleQuery.postgresql-simple"Initial state for result consumer.postgresql-simpleResult consumer.postgresql-simpleQuery template.postgresql-simpleQuery parameters.postgresql-simpleResult consumer.postgresql-simpleQuery template.postgresql-simpleResult consumer.b_`ijklmn   !"#/0136;}~b#nlmijk_` !"1;0  /3}~6(c) 2013 Leon P SmithBSD3&Leon P Smith <leon@melding-monads.com> experimentalNone%2UVpostgresql-simplelData representing either exactly one row of the result, or header or footer data depending on format.postgresql-simple<No more rows, and a count of the number of rows returned.postgresql-simpleIssue a COPY FROM STDIN or COPY TO STDOUTG query. In the former case, the connection's state will change to CopyIn; in the latter, CopyOutp. The connection must be in the ready state in order to call this function. Performs parameter subsitution.postgresql-simpleIssue a COPY FROM STDIN or COPY TO STDOUTG query. In the former case, the connection's state will change to CopyIn; in the latter, CopyOutx. The connection must be in the ready state in order to call this function. Does not perform parameter subsitution.postgresql-simpleRetrieve some data from a COPY TO STDOUT) query. A connection must be in the CopyOut= state in order to call this function. If this returns a  , the connection remains in the CopyOut state, if it returns 9, then the connection has reverted to the ready state.postgresql-simpleFeed some data to a COPY FROM STDIN query. Note that the data does not need to represent a single row, or even an integral number of rows. The net result of (putCopyData conn a >> putCopyData conn b is the same as putCopyData conn c whenever c == BS.append a b.A connection must be in the CopyIn7 state in order to call this function, otherwise a : exception will result. The connection remains in the CopyIn( state after this function is called.postgresql-simple Completes a COPY FROM STDIN1 query. Returns the number of rows processed.A connection must be in the CopyIn7 state in order to call this function, otherwise a j exception will result. The connection's state changes back to ready after this function is called.postgresql-simple Aborts a COPY FROM STDINy query. The string parameter is simply an arbitrary error message that may show up in the PostgreSQL server's log.A connection must be in the CopyIn7 state in order to call this function, otherwise a j exception will result. The connection's state changes back to ready after this function is called.  None%UV Mpostgresql-simple Perform a SELECT or other SQL query that is expected to return results. All results are retrieved and converted before this function returns.postgresql-simple A version of * that does not perform query substitution.postgresql-simple A version of  taking parser as argumentpostgresql-simple A version of  taking parser as argumentpostgresql-simpleExecute INSERT ... RETURNING, UPDATE ... RETURNINGU, or other SQL query that accepts multi-row input and is expected to return results.postgresql-simple A version of  taking parser as argumentNone%UVpostgresql-simple Perform a SELECT or other SQL query that is expected to return results. All results are retrieved and converted before this function returns.postgresql-simple A version of * that does not perform query substitution.postgresql-simple A version of  taking parser as argumentpostgresql-simple A version of  taking parser as argumentpostgresql-simpleExecute INSERT ... RETURNING, UPDATE ... RETURNINGU, or other SQL query that accepts multi-row input and is expected to return results.postgresql-simple A version of  taking parser as argument*+,*+-*+-./0./1./2./3.45.46.47.48.49:;<:;=:;>:;?:;?:;@:;A:;B:;C:;D:;E:;F:;G:;H:;I:;J:;KLMNOPQRSTUVWXYZ[[\]\^_`abcdefghijklmnopqrstuvwxyz{|}~M                                  ! " # $ % & ' ( ) * + , - . / 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 { | } ~       <<     N                                                                                      !"#$%%&'(()*+,-../012234556789:;;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{||}~5#       np !"#$%&'()*+,-./0123456789):):);)<)<)=)>)>)?)@)A)B)C)D)E)F)G)H)I)J)K)LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!!!........:;........(((()))))))..postgresql-simple-0.6.2-B4otSUJesgXLlPgdMnh3db Database.PostgreSQL.Simple.Types'Database.PostgreSQL.Simple.LargeObjects$Database.PostgreSQL.Simple.FromFieldDatabase.PostgreSQL.Simple!Database.PostgreSQL.Simple.ArraysDatabase.PostgreSQL.Simple.Ok(Database.PostgreSQL.Simple.Time.InternalDatabase.PostgreSQL.Simple.Time#Database.PostgreSQL.Simple.TypeInfo*Database.PostgreSQL.Simple.TypeInfo.Static)Database.PostgreSQL.Simple.TypeInfo.Macro"Database.PostgreSQL.Simple.ToField Database.PostgreSQL.Simple.ToRow Database.PostgreSQL.Simple.SqlQQ#Database.PostgreSQL.Simple.Internal'Database.PostgreSQL.Simple.Notification!Database.PostgreSQL.Simple.Errors&Database.PostgreSQL.Simple.Transaction"Database.PostgreSQL.Simple.FromRow Database.PostgreSQL.Simple.Range!Database.PostgreSQL.Simple.HStore*Database.PostgreSQL.Simple.HStore.Internal!Database.PostgreSQL.Simple.CursorDatabase.PostgreSQL.Simple.Copy!Database.PostgreSQL.Simple.Vector)Database.PostgreSQL.Simple.Vector.Unboxed!Database.PostgreSQL.Simple.Compat/Database.PostgreSQL.Simple.Time.Internal.Parser0Database.PostgreSQL.Simple.Time.Internal.Printer.Database.PostgreSQL.Simple.Time.Implementation)Database.PostgreSQL.Simple.TypeInfo.Types executeMany returningBasecommitControl.Applicativeoptional Control.Monadjoin1Database.PostgreSQL.Simple.Internal.PQResultUtils0Database.PostgreSQL.Simple.HStore.ImplementationOnly-0.1-4eYnxvcrr7tEbYgCvIkHLbData.Tuple.OnlyfromOnlyOnlybase GHC.IO.Device SeekFromEnd RelativeSeek AbsoluteSeekSeekMode GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOMode/postgresql-libpq-0.9.4.2-HyacS45qPUc33pszxfYdpMDatabase.PostgreSQL.LibPQBinaryTextFormatOid SingleTuple FatalError NonfatalError BadResponseCopyBothCopyInCopyOutTuplesOk CommandOk EmptyQuery ExecStatusLoFd ArrayFormatArrayPlainQuoted arrayFormatarrayquotedplainfmtdelimitfmt'esc$fEqArrayFormat$fShowArrayFormat$fOrdArrayFormat ManyErrorsOkErrors $fMonadFailOk $fMonadOk $fMonadPlusOk$fAlternativeOk$fApplicativeOk$fEqOk$fExceptionManyErrors$fShowOk $fFunctorOk$fShowManyErrors TimeZoneHMSDateZonedTimestamp UTCTimestampLocalTimestamp Unbounded NegInfinityFinite PosInfinity parseUTCTimeparseZonedTimeparseLocalTimeparseDayparseTimeOfDayparseUTCTimestampparseZonedTimestampparseLocalTimestamp parseDategetDaygetDate getTimeOfDay getLocalTimegetLocalTimestamp getTimeZonegetTimeZoneHMSlocalToUTCTimeOfDayHMS getZonedTimegetZonedTimestamp getUTCTimegetUTCTimestamp dayToBuildertimeOfDayToBuildertimeZoneToBuilderutcTimeToBuilderzonedTimeToBuilderlocalTimeToBuilderunboundedToBuilderutcTimestampToBuilderzonedTimestampToBuilderlocalTimestampToBuilder dateToBuildernominalDiffTimeToBuilder AttributeattnameatttypeTypeInfoBasicRange Compositetypoid typcategorytypdelimtypnametypelem rngsubtypetyprelid attributesstaticTypeInfoboolboolOidbyteabyteaOidcharcharOidnamenameOidint8int8Oidint2int2Oidint4int4Oidregproc regprocOidtexttextOidoidoidOidtidtidOidxidxidOidcidcidOidxmlxmlOidpointpointOidlseglsegOidpathpathOidboxboxOidpolygon polygonOidlinelineOidcidrcidrOidfloat4 float4Oidfloat8 float8Oidunknown unknownOidcircle circleOidmoneymoneyOidmacaddr macaddrOidinetinetOidbpchar bpcharOidvarchar varcharOiddatedateOidtimetimeOid timestamp timestampOid timestamptztimestamptzOidinterval intervalOidtimetz timetzOidbitbitOidvarbit varbitOidnumeric numericOid refcursor refcursorOidrecord recordOidvoidvoidOid array_recordarray_recordOid regprocedureregprocedureOidregoper regoperOid regoperatorregoperatorOidregclass regclassOidregtype regtypeOiduuiduuidOidjsonjsonOidjsonbjsonbOid int2vector int2vectorOid oidvector oidvectorOid array_xml array_xmlOid array_json array_jsonOid array_line array_lineOid array_cidr array_cidrOid array_circlearray_circleOid array_moneyarray_moneyOid array_bool array_boolOid array_byteaarray_byteaOid array_char array_charOid array_name array_nameOid array_int2 array_int2Oidarray_int2vectorarray_int2vectorOid array_int4 array_int4Oid array_regprocarray_regprocOid array_text array_textOid array_tid array_tidOid array_xid array_xidOid array_cid array_cidOidarray_oidvectorarray_oidvectorOid array_bpchararray_bpcharOid array_varchararray_varcharOid array_int8 array_int8Oid array_pointarray_pointOid array_lseg array_lsegOid array_path array_pathOid array_box array_boxOid array_float4array_float4Oid array_float8array_float8Oid array_polygonarray_polygonOid array_oid array_oidOid array_macaddrarray_macaddrOid array_inet array_inetOidarray_timestamparray_timestampOid array_date array_dateOid array_time array_timeOidarray_timestamptzarray_timestamptzOidarray_intervalarray_intervalOid array_numericarray_numericOid array_timetzarray_timetzOid array_bit array_bitOid array_varbitarray_varbitOidarray_refcursorarray_refcursorOidarray_regprocedurearray_regprocedureOid array_regoperarray_regoperOidarray_regoperatorarray_regoperatorOidarray_regclassarray_regclassOid array_regtypearray_regtypeOid array_uuid array_uuidOid array_jsonbarray_jsonbOid int4range int4rangeOid _int4range _int4rangeOidnumrange numrangeOid _numrange _numrangeOidtsrange tsrangeOid_tsrange _tsrangeOid tstzrange tstzrangeOid _tstzrange _tstzrangeOid daterange daterangeOid _daterange _daterangeOid int8range int8rangeOid _int8range _int8rangeOidValues Savepoint:.PGArray fromPGArrayQualifiedIdentifier IdentifierfromIdentifier fromBinaryInQuery fromQueryDefaultNull$fEqNull $fMonoidQuery$fSemigroupQuery$fIsStringQuery $fReadQuery $fShowQuery$fHashableIdentifier$fIsStringQualifiedIdentifier$fHashableQualifiedIdentifier $fReadNull $fShowNull $fReadDefault $fShowDefault $fEqQuery $fOrdQuery$fEqIn$fOrdIn$fReadIn$fShowIn $fFunctorIn $fEqBinary $fOrdBinary $fReadBinary $fShowBinary$fFunctorBinary$fEqIdentifier$fOrdIdentifier$fReadIdentifier$fShowIdentifier$fIsStringIdentifier$fEqQualifiedIdentifier$fOrdQualifiedIdentifier$fReadQualifiedIdentifier$fShowQualifiedIdentifier $fEqPGArray $fOrdPGArray $fReadPGArray $fShowPGArray$fFunctorPGArray$fEq:.$fOrd:.$fShow:.$fRead:. $fEqSavepoint$fOrdSavepoint$fShowSavepoint$fReadSavepoint $fEqValues $fOrdValues $fShowValues $fReadValues mkCompats inlineTypoidToFieldActionEscape EscapeByteAEscapeIdentifierManyToRowtoRowtoField toJSONFieldinQuotes $fShowAction$fToFieldValues$fToFieldValue $fToFieldUUID$fToFieldVector$fToFieldPGArray$fToFieldNominalDiffTime$fToFieldUnbounded$fToFieldUnbounded0$fToFieldUnbounded1$fToFieldUnbounded2$fToFieldTimeOfDay $fToFieldDay$fToFieldLocalTime$fToFieldZonedTime$fToFieldUTCTime $fToFieldCI $fToFieldCI0 $fToFieldText $fToField[]$fToFieldText0$fToFieldByteString$fToFieldByteString0$fToFieldQualifiedIdentifier$fToFieldIdentifier$fToFieldBinary$fToFieldBinary0$fToFieldScientific$fToFieldDouble$fToFieldFloat $fToFieldOid$fToFieldWord64 $fToFieldWord$fToFieldWord32$fToFieldWord16$fToFieldWord8$fToFieldInteger$fToFieldInt64 $fToFieldInt$fToFieldInt32$fToFieldInt16 $fToFieldInt8 $fToFieldBool$fToFieldDefault $fToFieldNull $fToFieldIn$fToFieldMaybe$fToFieldAction $fGToRowU1 $fGToRowK1 $fGToRow:*: $fGToRowM1 $fToRow:. $fToRow[]$fToRow(,,,,,,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,,)$fToRow(,,,,,,,,,,,)$fToRow(,,,,,,,,,,)$fToRow(,,,,,,,,,)$fToRow(,,,,,,,,)$fToRow(,,,,,,,)$fToRow(,,,,,,)$fToRow(,,,,,) $fToRow(,,,,) $fToRow(,,,) $fToRow(,,) $fToRow(,) $fToRowOnly $fToRow()sql Conversion runConversion RowParserRPunRPRowrow rowresult ConnectInfo connectHost connectPort connectUserconnectPasswordconnectDatabase FormatError fmtMessagefmtQuery fmtParams QueryError qeMessageqeQuerySqlErrorsqlState sqlExecStatus sqlErrorMsgsqlErrorDetail sqlErrorHint ConnectionconnectionHandleconnectionObjectsconnectionTempNameCounter TypeInfoCacheFieldresultcolumntypeOid fatalErrordefaultConnectInfoconnectconnectPostgreSQL connectdbpostgreSQLConnectionStringoid2intexecexecute_ finishExecutethrowResultErrordisconnectedErrorwithConnectionclosenewNullConnection liftRowParserliftConversion conversionMapconversionError newTempNamefdError libPQErrorthrowLibPQErrorfmtError fmtErrorBsquote buildAction checkError escapeWrapescapeStringConnescapeIdentifierescapeByteaConnbreakOnSingleQuestionMark$fEqConnection$fExceptionSqlError$fExceptionQueryError$fExceptionFormatError$fMonadPlusConversion$fMonadConversion$fAlternativeConversion$fApplicativeConversion$fFunctorConversion $fEqSqlError$fShowSqlError$fEqQueryError$fShowQueryError$fEqFormatError$fShowFormatError$fGenericConnectInfo$fEqConnectInfo$fReadConnectInfo$fShowConnectInfo$fFunctorRowParser$fApplicativeRowParser$fAlternativeRowParser$fMonadRowParser NotificationnotificationPidnotificationChannelnotificationDatagetNotificationgetNotificationNonBlocking getBackendPID$fShowNotification$fEqNotificationloCreatloCreateloImportloImportWithOidloExportloOpenloWriteloReadloSeekloTell loTruncateloCloseloUnlinkConstraintViolationNotNullViolationForeignKeyViolationUniqueViolationCheckViolationExclusionViolationconstraintViolationconstraintViolationEcatchViolationisSerializationErrorisNoActiveTransactionErrorisFailedTransactionError$fExceptionConstraintViolation$fShowConstraintViolation$fEqConstraintViolation$fOrdConstraintViolationTransactionModeisolationLevel readWriteModeDefaultReadWriteMode ReadWriteReadOnlyIsolationLevelDefaultIsolationLevel ReadCommittedRepeatableRead SerializabledefaultTransactionModedefaultIsolationLeveldefaultReadWriteModewithTransactionwithTransactionSerializablewithTransactionLevelwithTransactionModewithTransactionModeRetryrollbackbegin beginLevel beginMode withSavepoint newSavepointreleaseSavepointrollbackToSavepointrollbackToAndReleaseSavepoint$fShowIsolationLevel$fEqIsolationLevel$fOrdIsolationLevel$fEnumIsolationLevel$fBoundedIsolationLevel$fShowReadWriteMode$fEqReadWriteMode$fOrdReadWriteMode$fEnumReadWriteMode$fBoundedReadWriteMode$fShowTransactionMode$fEqTransactionMode FromFieldFromRowexecutequery_query getTypeInfo fromField FieldParser ResultError IncompatibleUnexpectedNullConversionFailed errSQLTypeerrSQLTableOid errSQLFielderrHaskellType errMessagetypenametypeInfo typeInfoByOidtableOid tableColumnformat optionalFieldpgArrayFieldParser fromJSONField returnError$fExceptionResultError$fFromFieldMVar$fFromFieldIORef$fFromFieldValue$fFromFieldUUID$fFromFieldMVector$fFromFieldVector$fFromFieldPGArray$fFromFieldEither$fFromFieldUnbounded$fFromFieldUnbounded0$fFromFieldUnbounded1$fFromFieldUnbounded2$fFromFieldTimeOfDay$fFromFieldDay$fFromFieldLocalTime$fFromFieldZonedTime$fFromFieldUTCTime $fFromField[] $fFromFieldCI$fFromFieldCI0$fFromFieldText$fFromFieldText0$fFromFieldBinary$fFromFieldBinary0$fFromFieldByteString$fFromFieldOid$fFromFieldByteString0$fFromFieldScientific$fFromFieldRatio$fFromFieldDouble$fFromFieldFloat$fFromFieldInteger$fFromFieldInt64$fFromFieldInt$fFromFieldInt32$fFromFieldInt16$fFromFieldChar$fFromFieldBool$fFromFieldNull$fFromFieldMaybe $fFromField()$fEqResultError$fShowResultErrorPGRange RangeBound Inclusive Exclusiveempty isEmptyByisEmptycontains containsByfromFieldRange$fToFieldPGRange$fToFieldPGRange0$fToFieldPGRange1$fToFieldPGRange2$fToFieldPGRange3$fToFieldPGRange4$fToFieldPGRange5$fToFieldPGRange6$fToFieldPGRange7$fToFieldPGRange8$fToFieldPGRange9$fToFieldPGRange10$fToFieldPGRange11$fToFieldPGRange12$fToFieldPGRange13$fToFieldPGRange14$fToFieldPGRange15$fToFieldPGRange16$fToFieldPGRange17$fToFieldPGRange18$fToFieldPGRange19$fToFieldPGRange20$fToFieldPGRange21$fToFieldPGRange22$fFromFieldPGRange $fEqPGRange$fShowRangeBound$fEqRangeBound$fFunctorRangeBound $fShowPGRange$fFunctorPGRange HStoreMap fromHStoreMap HStoreListfromHStoreList HStoreText ToHStoreText toHStoreText HStoreBuilderEmptyCommaToHStoretoHStore toBuildertoLazyByteStringhstoreparseHStoreList parseHStoreparseHStoreKeyValparseHStoreTextfromRow fieldWithfieldnumFieldsRemaining $fGFromRowU1 $fGFromRowK1 $fGFromRow:*: $fGFromRowM1 $fFromRow:.$fFromRowMaybe$fFromRowVector$fFromRowMaybe0 $fFromRow[]$fFromRowMaybe1$fFromRow(,,,,,,,,,,,,,,,,,,,)$fFromRowMaybe2$fFromRow(,,,,,,,,,,,,,,,,,,)$fFromRowMaybe3$fFromRow(,,,,,,,,,,,,,,,,,)$fFromRowMaybe4$fFromRow(,,,,,,,,,,,,,,,,)$fFromRowMaybe5$fFromRow(,,,,,,,,,,,,,,,)$fFromRowMaybe6$fFromRow(,,,,,,,,,,,,,,)$fFromRowMaybe7$fFromRow(,,,,,,,,,,,,,)$fFromRowMaybe8$fFromRow(,,,,,,,,,,,,)$fFromRowMaybe9$fFromRow(,,,,,,,,,,,)$fFromRowMaybe10$fFromRow(,,,,,,,,,,)$fFromRowMaybe11$fFromRow(,,,,,,,,,)$fFromRowMaybe12$fFromRow(,,,,,,,,)$fFromRowMaybe13$fFromRow(,,,,,,,)$fFromRowMaybe14$fFromRow(,,,,,,)$fFromRowMaybe15$fFromRow(,,,,,)$fFromRowMaybe16$fFromRow(,,,,)$fFromRowMaybe17$fFromRow(,,,)$fFromRowMaybe18 $fFromRow(,,)$fFromRowMaybe19 $fFromRow(,)$fFromRowMaybe20 $fFromRowOnlyCursor declareCursor closeCursorfoldForwardWithParser foldForward FoldOptions fetchQuantitytransactionMode FetchQuantity AutomaticFixed formatQuery formatMany returningWith queryWith queryWith_foldfoldWithdefaultFoldOptionsfoldWithOptionsfoldWithOptionsAndParserfold_ foldWith_foldWithOptions_foldWithOptionsAndParser_forEach forEachWithforEach_ forEachWith_ CopyOutResult CopyOutRow CopyOutDonecopycopy_ getCopyData putCopyData putCopyEnd putCopyError$fEqCopyOutResult$fShowCopyOutResultmaskGHC.IOGHC.Base<> GHC.IO.UnsafeunsafeDupablePerformIO)scientific-0.3.6.2-F7ipbcKfqm39QUhGiudUt7!Data.Text.Lazy.Builder.ScientificscientificBuilder toByteStringtoPicofromPicoday twoDigits timeOfDaysecondstimeZone GHC.MaybeNothing timeZoneHMS localTimeutcTime zonedTime UTCOffsetHMSnominalDiffTime getUnbounded Data.StringIsStringbytestring-0.10.8.2Data.ByteString.Internal ByteStringghc-prim GHC.TypesBool$aeson-1.4.2.0-KDbkGdCH8KWK3joT2FuDwNData.Aeson.Types.InternalValueData.Aeson.Types.ToJSONtoJSON GHC.GenericsGenericSystem.Posix.TypesCPidControl.Exception.Base handleJust rollback_ResultfromFieldJSONByteStringData.Aeson.Types.FromJSONFromJSONData.Typeable.InternalTypeableMaybeJust Data.Functor<$>eqGHC.MVarMVar GHC.IORefIORef Data.EitherRight*attoparsec-0.13.2.2-JtWk3gWffmo8exA54HD0hS Data.Attoparsec.ByteString.Char8doubleData.Scientific ScientificGHC.RealRational\/TrueFalsepgrange doubleQuotedrangeToBuilderByfinishQueryWithfinishQueryWithVfinishQueryWithVU getRowWith$fToHStoreTextByteString$fToHStoreTextByteString0$fFromFieldHStoreList$fToHStoreHStoreList escapeAppendskipWhiteSpaceparseHStoreTextsLeft