Rg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ experimental&Leon P Smith <leon@melding-monads.com>NoneEA structure representing some of the metadata regarding a PostgreSQL  type, mostly taken from the pg_type table.  !"#$%&'( !"#$%&'($" %&'(%&'(#%&'(!%&'( experimental&Leon P Smith <leon@melding-monads.com>None)p assumes its input is in the range [0..9] -pad2 assumes its input is in the range [0..99] #pad4 assumes its input is positive 6)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN4)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN3)*+,-0/.123456789:;<=>?@ABCDEFGHIJKLMN experimental&Leon P Smith <leon@melding-monads.com>None :;<=>?@ABC :;<=>?@ABC  experimental&Leon P Smith <leon@melding-monads.com>NoneOO2 is a quasiquoter that eases the syntactic burden E of writing big sql statements in Haskell source code. For example:   {-# LANGUAGE QuasiQuotes #-}  , query conn [sql| SELECT column_a, column_b 4 FROM table1 NATURAL JOIN table2 0 WHERE ? <= time AND time < ? % AND name LIKE ? & ORDER BY size DESC 7 LIMIT 100 |] ' (beginTime,endTime,string) AThis quasiquoter attempts to mimimize whitespace; otherwise the F above query would consist of approximately half whitespace when sent F to the database backend. It also recognizes and strips out standard  sql comments --. FThe implementation of the whitespace reducer is currently incomplete. E Thus it can mess up your syntax in cases where whitespace should be J preserved as-is. It does preserve whitespace inside standard SQL string J literals. But it can get confused by the non-standard PostgreSQL string J literal syntax (which is the default setting in PostgreSQL 8 and below), L the extended escape string syntax, quoted identifiers, and other similar  constructs. COf course, this caveat only applies to text written inside the SQL E 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. OOOO experimental&Leon P Smith <leon@melding-monads.com>None)*+,-./0123456789DEFGHIJKLMN-0/.)+*,412359678DGHIEFNKLMJ experimental&Leon P Smith <leon@melding-monads.com>None0PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~= !"#$%&'(PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~I$" %&'(%&'(#%&'(!%&'(PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  experimental&Leon P Smith <leon@melding-monads.com>Nonec444/  experimental&Leon P Smith <leon@melding-monads.com>NoneEParse one of three primitive field formats: array, quoted and plain. Recognizes a quoted string. IRecognizes a plain string literal, not containing quotes or brackets and + not containing the delimiter character. JFormat an array format item, using the delimiter character if the item is  itself an array. IFormat a list of array format items, inserting the appropriate delimiter H between them. When the items are arrays, they will be delimited with G commas; otherwise, they are delimited with the passed-in-delimiter. JFormat an array format item, using the delimiter character if the item is J itself an array, optionally applying quoting rules. Creates copies for  safety when used in  FromField instances. CEscape a string according to Postgres double-quoted string format.  experimental&Leon P Smith <leon@melding-monads.com>None>A composite type to parse your custom data structures without 5 having to define dummy newtype wrappers every time.  # instance FromRow MyData where ...  $ instance FromRow MyData2 where ... &then I can do the following for free:   res <- query' c ...  forM res $ \"(MyData{..} :. MyData2{..}) -> do  .... Wrap binary data for use as a bytea value. $Wrap a list of values for use in an IN clause. Replaces a  single "?"1 character with a parenthesized list of rendered  values.  Example: D query c "select * from whatever where id in ?" (Only (In [3,4,5])) A single-value " collection". AThis is useful if you need to supply a single parameter to a SQL 6 query, or extract a single column from a SQL result. Parameter example:  query c " select x from scores where x > ?" ( (42::Int))Result example: xs < - query_ c "select id from users"  forM_ xs $ \( id) -> {- ... -}>A query string. This type is intended to make it difficult to E construct a SQL query by concatenating string fragments, as that is A 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 OverloadedStrings 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 , and literal Haskell strings B that contain Unicode characters will be correctly transformed to  UTF-8. A placeholder for the SQL NULL value.     experimental&Leon P Smith <leon@melding-monads.com>None$Returns an expression that has type   -> , true if the " oid is equal to any one of the %s of the given s. Literally substitute the % of a  expression. ! Returns an expression of type  . Useful because GHC tends  not to fold constants.   experimental&Leon P Smith <leon@melding-monads.com>None >A type that may be used as a single parameter to a SQL query. 6Prepare a value for substitution into a query string. <How to render an element when substituting it into a query. +Concatenate a series of rendering actions.  Escape binary data for use as a bytea literal. Include surrounding  quotes. This is used by the  newtype wrapper. >Escape and enclose in quotes before substituting. Use for all < text-like types, and anything else that may contain unsafe  characters when rendered. ;Render without escaping or quoting. Use for non-text types  such as numbers, when you are certain that they will not A introduce formatting vulnerabilities via use of characters such  as spaces or "'". "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  = method for Haskell types that have a JSON representation in  PostgreSQL. 0Surround a string with single-quote characters: "'" This function does not perform any other escaping. 0      +      experimental&Leon P Smith <leon@melding-monads.com>None>A collection type that can be turned into a list of rendering  s. Instances should use the render method of the Param class : to perform conversion of each element of the collection.  ToField a collection of values.  !"#$ !"#$ experimentalleon@melding-monads.com Safe-Inferred<a way to reify a list of exceptions into a single exception %Two 4 cases are considered equal, regardless of what the " list of exceptions looks like. &'()*%&'()*% experimental&Leon P Smith <leon@melding-monads.com>None Exception thrown if query is used to perform an INSERT-like  operation, or execute is used to perform a SELECT-like operation. 5A Field represents metadata about a particular field You don':t particularly want to retain these structures for a long D period of time, as they will retain the entire query result, not  just the field metadata AThis returns the type oid associated with the column. Analogous  to libpq's PQftype.  1Default information for setting up a connection. Defaults are as follows:  Server on  localhost  Port on 5432  User postgres  No password  Database postgres !Use as in the following example: ? connect defaultConnectInfo { connectHost = "db.example.com" }  BConnect with the given username to the given database. Will throw & an exception if it cannot connect.  AAttempt to make a connection based on a libpq connection string.  See  <http://www.postgresql.org/docs/9.1/static/libpq-connect.html  for more information.  Turns a 0 data structure into a libpq connection string.  A version of execute+ that does not perform query substitution. HAtomically perform an action with the database handle, if there is one. B     +,-./01;     ;     $     +,-./01leon@melding-monads.comNone2 !"#$%&'()  !"#$%&'() !"#$%&'() 2 !"#$%&'() experimentalleon@melding-monads.comNone/DReturns a single notification. If no notifications are available,  / blocks until one arrives. 0Non-blocking variant of /#. Returns a single notification, = if available. If no notifications are available, returns 3. *+,-.4/0*+,-./0*+,-./0*+,-.4/0 experimental&Leon P Smith <leon@melding-monads.com>None2/Relation name (usually table), constraint name 3Name of violated constraint 4+Table name and name of violated constraint 5The field is a column name 6Tries to convert  to ConstrainViolation, checks sqlState and . succeedes only if able to parse sqlErrorMsg. G createUser = catchJust constraintViolation catcher $ execute conn ...  where 4 catcher UniqueViolation "user_login_key" = ...  catcher _ = ... 7<Like constraintViolation, but also packs original SqlError. H createUser = catchJust constraintViolationE catcher $ execute conn ...  where 9 catcher (_, UniqueViolation "user_login_key") = ...  catcher (e, _) = throwIO e 8ECatches SqlError, tries to convert to ConstraintViolation, re-throws 6 on fail. Provides alternative interface to catchJust 8 createUser = catchViolation catcher $ execute conn ...  where 8 catcher _ (UniqueViolation "user_login_key") = ...  catcher e _ = throwIO e 1234567856789:;9: 123456789:; 154326789:; 1543267856789:;9:None;Like </, but backported to base before version 4.3.0. 9Note that the restore callback is monomorphic, unlike in <. This K 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  withTransactionMode6 function calls the restore callback only once, so we  don't need that polymorphism. ;=>;;NoneE'the read-write mode will be taken from  PostgreSQL's per-connection  default_transaction_read_only variable, ) which is initialized according to the  server'%s config. The default configuration  is D. F:Of the four isolation levels defined by the SQL standard, K these are the three levels distinguished by PostgreSQL as of version 9.0.  See  >http://www.postgresql.org/docs/9.1/static/transaction-iso.html < for more information. Note that prior to PostgreSQL 9.0, H  was equivalent to G. J'the isolation level will be taken from  PostgreSQL's per-connection  default_transaction_isolation variable, ) which is initialized according to the  server'%s config. The default configuration  is I. N,Execute an action inside a SQL transaction. -This function initiates a transaction with a "begin  transaction"3 statement, then executes the supplied action. If = the action succeeds, the transaction will be completed with   before this function returns. If the action throws any kind of exception (not just a J PostgreSQL-related exception), the transaction will be rolled back using  S', then the exception will be rethrown. For nesting transactions, see X. OExecute an action inside of a G transaction. If a H serialization failure occurs, roll back the transaction and try again. ? Be warned that this may execute the IO action multiple times. A G8 transaction creates the illusion that your program has J exclusive access to the database. This means that, even in a concurrent L setting, you can perform queries in sequence without having to worry about 7 what might happen between one statement and the next.  Think of it as STM, but without retry. PIExecute an action inside a SQL transaction with a given isolation level. QJExecute an action inside a SQL transaction with a given transaction mode. RLike Q&, but also takes a custom callback to 4 determine if a transaction should be retried if an  occurs. E 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 O. SRollback a transaction. TCommit a transaction. UBegin a transaction. V1Begin a transaction with a given isolation level W2Begin a transaction with a given transaction mode XKCreate a savepoint, and roll back to it if an error occurs. This may only 9 be used inside of a transaction, and provides a sort of  "nested transaction". See  @http://www.postgresql.org/docs/current/static/sql-savepoint.html YHCreate a new savepoint. This may only be used inside of a transaction. Z-Destroy a savepoint, but retain its effects. Warning: this will throw a  matching ; if . the transaction is aborted due to an error. T would merely warn and  roll back. [@Roll back to a savepoint. This will not release the savepoint. \?Roll back to a savepoint and release it. This is like calling  [ followed by Z, but avoids a $ round trip to the database server. >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\#9:;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\#NPQRO>?@AFJIHGBEDCKLMUVWTSXYZ[\9:;>?@ABEDCFJIHGKLMNOPQRSTUVWXYZ[\ experimental&Leon P Smith <leon@melding-monads.com>NoneaAReturns the metadata of the type with a particular oid. To find  this data, a! first consults postgresql-simple's  built-in P$ table, then checks the connection's + typeinfo cache. Finally, the database's pg_type table will @ be queried only if necessary, and the result will be stored  in the connections' s cache. a?@ !"#$%&'(aa$" %&'(%&'(#%&'(!%&'(a?@ experimental&Leon P Smith <leon@melding-monads.com>None.<.A type that may be converted from a SQL type. b(Convert a SQL value to a Haskell value. FReturns a list of exceptions if the conversion fails. In the case of 3 library instances, this will usually be a single d, but  may be a UnicodeException. )Note that retaining any reference to the  or   arguments causes the entire LibPQ.A to be retained. . Thus, as a rule of thumb, implementations of b should ? not refer to these values after the result has been evaluated @ to WHNF. But it can be profitable to break this rule when you  know it won'$t cause memory management problems. ?The instances included with postgresql-simple follow this rule 9 of thumb (modulo bugs). For example, the instance for   uses B to avoid such a reference. d=Exception thrown if conversion from a SQL value to a Haskell  value fails. e0The SQL value could not be parsed, or could not 0 be represented as a valid Haskell value, or an 4 unexpected low-level error occurred (e.g. mismatch - between metadata and actual data in a row). fA SQL NULL" was encountered when the Haskell  type did not permit it. g.The SQL and Haskell types are not compatible. mFReturns the data type name. This is the preferred way of identifying G 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, B postgresql-simple will check a per-connection cache, and then  finally query the database's meta-schema. pEReturns the name of the column. This is often determined by a table + definition, but it can be set using an as clause. q)Returns the name of the object id of the table associated with the  column, if any. Returns 3 when there is no such table; K for example a computed column does not have a table associated with it.  Analogous to libpq's PQftable. rGIf the column has a table associated with it, this returns the number J off the associated table column. Numbering starts from 0. Analogous  to libpq's  PQftablecol. sJThis returns whether the data was returned in a binary or textual format.  Analogous to libpq's  PQfformat. tParse a field to a JSON  and convert that into a  Haskell value using C. 7This can be used as the default implementation for the b = method for Haskell types that have a JSON representation in  PostgreSQL. The D1 constraint is required to show more informative $ error messages when parsing fails. u#Given one of the constructors from d, the field,  and an l), this fills in the other fields in the ' exception value and returns it in a 'Left . SomeException'  constructor. Ejson F=any postgresql array whose elements are compatible with type a G1Compatible with both types. Conversions to type b are & preferred, the conversion to type a will be tried after  the H conversion fails. Idate J timestamp K timestamptz L timestamptz Mtime Ndate O timestamp P timestamptz Q timestamptz R name, text, "char", bpchar, varchar S name, text, "char", bpchar, varchar T name, text, "char", bpchar, varchar Ubytea Vbytea Wbytea, name, text, "char", bpchar, varchar, unknown Xoid Ybytea, name, text, "char", bpchar, varchar, unknown Z$int2, int4, float4, float8, numeric [int2, int4, float4, float8 \ int2, float4 ]int2, int4, int8 ^int2, int4, int8 _<int2, int4, and if compiled as 64-bit code, int8 as well. + This library was compiled as 32-bit code. ` int2, int4 aint2 b"char" cbool d;compatible with any data type, but the value must be null eCFor dealing with null values. Compatible with any postgresql type  compatible with type a(. Note that the type is not checked if A the value is null, although it is inadvisable to rely on this  behavior. fvoid F<gbcdefghijklhmnopqrsijkltmnopqrstuuEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefv1  !"#$%&'(<bcdefghijklmnopqrstuI<bcdgfehijklhijklhijklum$" %&'(%&'(#%&'(!%&'(nopqrs t=<bgcdgfehijklhijklhijklhmnopqrsijkltmnopqrstuuEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefv experimental&Leon P Smith <leon@melding-monads.com>NonezGRepresents escape text, ready to be the key or value to a hstore value } Represents valid hstore syntax. whstore xhstore yAssumed to be UTF-8 encoded zAssumed to be UTF-8 encoded $vwxyz{{|}|}~~wxyzvwxyz{{|}|}~~vwxyz{{|}}|~~wxyz experimental&Leon P Smith <leon@melding-monads.com>None vwxyz{|}~ xyvw~}{|z experimental&Leon P Smith <leon@melding-monads.com>Nonez{}|} experimental&Leon P Smith <leon@melding-monads.com>None=CA collection type that can be converted from a sequence of fields. N Instances are provided for tuples up to 10 elements and lists of any length. KNote that instances can be defined outside of postgresql-simple, which is " often useful. For example, here''s an instance for a user-defined pair:  6data User = User { name :: String, fileQuota :: Int }   instance = User where  fromRow = User <$>  <*>  The number of calls to * must match the number of fields returned 5 in a single row of the query result. Otherwise, a e  exception will be thrown.  Note that  evaluates it'+s result to WHNF, so the caveats listed in L mysql-simple and very early versions of postgresql-simple no longer apply. K Instead, look at the caveats associated with user-defined implementations  of b. ==== experimental&Leon P Smith <leon@melding-monads.com>None ]Execute a multi-row INSERT, UPDATE!, or other SQL query that is not  expected to return results. %Returns the number of rows affected. Throws 0 if the query could not be formatted correctly. ^ Execute an INSERT, UPDATE!, or other SQL query that is not  expected to return results. %Returns the number of rows affected. Throws 0 if the query could not be formatted correctly. _ A version of `+ that does not perform query substitution. ` Perform a SELECT/ or other SQL query that is expected to return > results. All results are retrieved and converted before this  function returns. CWhen processing large results, this function will consume a lot of % client-side memory. Consider using  instead. Exceptions that may be thrown:  5: the query string could not be formatted correctly.  5: the result contains no columns (i.e. you should be  using ^ instead of `).  d: result conversion failed. Exception thrown if a # could not be formatted correctly. ! This may occur if the number of '?' characters in the query : string does not match the number of parameters provided. Format a query string. DThis function is exposed to help with debugging and logging. Do not * use it to prepare queries for execution. DString parameters are escaped according to the character set in use  on the . Throws , if the query string could not be formatted  correctly. 6Format a query string with a variable number of rows. DThis 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 , if the query string could not be formatted  correctly. Execute INSERT ... RETURNING, UPDATE ... RETURNING, or other SQL G query that accepts multi-row input and is expected to return results. # Note that it is possible to write  ` conn INSERT ... RETURNING ... ... F in cases where you are only inserting a single row, and do not need  functionality analogous to ]. Throws 0 if the query could not be formatted correctly.  Perform a SELECT/ or other SQL query that is expected to return B results. Results are streamed incrementally from the server, and  consumed via a left fold. @When dealing with small results, it may be simpler (and perhaps  faster) to use ` instead.  This fold is not0 strict. The stream consumer is responsible for < forcing the evaluation of its result to avoid space leaks. Exceptions that may be thrown:  5: the query string could not be formatted correctly.  5: the result contains no columns (i.e. you should be  using ^ instead of `).  d: result conversion failed.  A version of + that does not perform query substitution.  A version of ( that does not transform a state value.  A version of + that does not perform query substitution. %]^_`Query. #Initial state for result consumer. Result consumer. Query. #Initial state for result consumer. Result consumer. Query template. Query parameters. Result consumer. Query template. Result consumer. O    =NSTUX]^_`dhklU=dhklhklhkl    `_^]NXUTS]^_` experimental&Leon P Smith <leon@melding-monads.com>None!No more rows, and a count of the  number of rows returned. !Data representing either exactly % one row of the result, or header ' or footer data depending on format. Issue a COPY FROM STDIN or COPY TO STDOUT query. In the former  case, the connection's state will change to CopyIn; in the latter,  CopyOut6. The connection must be in the ready state in order ; to call this function. Performs parameter subsitution. Issue a COPY FROM STDIN or COPY TO STDOUT query. In the former  case, the connection's state will change to CopyIn; in the latter,  CopyOut6. The connection must be in the ready state in order C to call this function. Does not perform parameter subsitution. Retrieve some data from a COPY TO STDOUT query. A connection  must be in the CopyOut0 state in order to call this function. If this  returns a  , the connection remains in the CopyOut state,  if it returns *, then the connection has reverted to the  ready state. Feed some data to a COPY FROM STDIN query. Note that A 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 CopyIn state in order to call this  function, otherwise a  exception will result. The  connection remains in the CopyIn state after this function  is called.  Completes a COPY FROM STDIN$ query. Returns the number of rows  processed. A connection must be in the CopyIn state in order to call this  function, otherwise a  exception will result. The  connection'2s state changes back to ready after this function  is called.  Aborts a COPY FROM STDIN( query. The string parameter is simply A an arbitrary error message that may show up in the PostgreSQL  server's log. A connection must be in the CopyIn state in order to call this  function, otherwise a  exception will result. The  connection'2s state changes back to ready after this function  is called.     !"#$%$&$'$($)*+,*+-*+.*+/*+/*+0*+1*+2*+3*+4*+5*+6*+7*+8*+9::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno pqrstuvwxyz{|}~               J                        / ,            C --              !"#$%&'()*+,-./01234556789:;<=>?@ABCDEFGHHIJ(KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvuwxyz{||}}~   r s t u v w x y z { | } ~                                               *+ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY~Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ppostgresql-simple-0.3.7.1'Database.PostgreSQL.Simple.LargeObjects$Database.PostgreSQL.Simple.FromField Database.PostgreSQL.Simple.TypesDatabase.PostgreSQL.Simple#Database.PostgreSQL.Simple.TypeInfo*Database.PostgreSQL.Simple.TypeInfo.StaticDatabase.PostgreSQL.Simple.Time(Database.PostgreSQL.Simple.Time.Internal Database.PostgreSQL.Simple.SqlQQ'Database.PostgreSQL.Simple.BuiltinTypes!Database.PostgreSQL.Simple.Arrays)Database.PostgreSQL.Simple.TypeInfo.Macro"Database.PostgreSQL.Simple.ToField Database.PostgreSQL.Simple.ToRowDatabase.PostgreSQL.Simple.Ok#Database.PostgreSQL.Simple.Internal'Database.PostgreSQL.Simple.Notification!Database.PostgreSQL.Simple.Errors"Database.PostgreSQL.Simple.FromRow&Database.PostgreSQL.Simple.Transaction!Database.PostgreSQL.Simple.HStoreDatabase.PostgreSQL.Simple.Copy)Database.PostgreSQL.Simple.TypeInfo.Types.Database.PostgreSQL.Simple.Time.Implementation!Database.PostgreSQL.Simple.CompatBasecommit0Database.PostgreSQL.Simple.HStore.Implementation*Database.PostgreSQL.Simple.HStore.Internalbase GHC.IO.Device AbsoluteSeek RelativeSeek SeekFromEndSeekMode GHC.IO.IOModeReadMode WriteMode AppendMode ReadWriteModeIOModepostgresql-libpq-0.8.2.4Database.PostgreSQL.LibPQTextBinaryFormatOid EmptyQuery CommandOkTuplesOkCopyOutCopyIn BadResponse NonfatalError FatalError ExecStatusLoFd AttributeattnameatttypeTypeInfo Compositetyprelid attributesRange rngsubtypeArraytypelemBasictypoid typcategorytypdelimtypnameDateZonedTimestamp UTCTimestampLocalTimestamp Unbounded PosInfinityFinite NegInfinity parseUTCTimeparseZonedTimeparseLocalTimeparseDayparseTimeOfDayparseUTCTimestampparseZonedTimestampparseLocalTimestamp parseDategetDaygetDate getTimeOfDay getLocalTimegetLocalTimestamp getTimeZone getZonedTimegetZonedTimestamp getUTCTimegetUTCTimestamp dayToBuildertimeOfDayToBuildertimeZoneToBuilderutcTimeToBuilderzonedTimeToBuilderlocalTimeToBuilderunboundedToBuilderutcTimestampToBuilderzonedTimestampToBuilderlocalTimestampToBuilder dateToBuildersqlstaticTypeInfoboolbyteacharnameint8int2int4regproctextoidtidxidcidxmlpointlsegpathboxpolygonlinecidrfloat4float8abstimereltime tintervalunknowncirclemoneymacaddrinetbpcharvarchardatetime timestamp timestamptzintervaltimetzbitvarbitnumeric refcursorrecordvoiduuidjson BuiltinTypeJSONUUIDVoidRecord RefCursorNumericVarBitBitTimeTZInterval TimestampTZ TimestampTimeVarCharBpCharInetMacAddrMoneyCircleUnknown TIntervalRelTimeAbsTimeFloat8Float4CidrLinePolygonBoxPathLSegPointXmlCidXidTidRegProcInt4Int2Int8NameCharByteABool builtin2oid oid2builtinbuiltin2typname oid2typname ArrayFormatQuotedPlain arrayFormatarrayquotedplainfmtdelimitfmt'esc Savepoint:.InOnlyfromOnlyQuery fromQueryNull mkCompats inlineTypoidToFieldToRowtoFieldActionMany EscapeByteAEscape toJSONFieldinQuotestoRow ManyErrorsOkErrors Conversion runConversion RowParserRPunRPRowrow rowresult ConnectInfo connectHost connectPort connectUserconnectPasswordconnectDatabase QueryError qeMessageqeQuerySqlErrorsqlState sqlExecStatus sqlErrorMsgsqlErrorDetail sqlErrorHint ConnectionconnectionHandleconnectionObjectsconnectionTempNameCounter TypeInfoCacheFieldresultcolumntypeOid fatalErrordefaultConnectInfoconnectconnectPostgreSQLpostgreSQLConnectionStringoid2intexecexecute_ finishExecutethrowResultErrordisconnectedErrorwithConnectionclosenewNullConnection liftRowParserliftConversion conversionMapconversionError newTempNamefdErrorloCreatloCreateloImportloImportWithOidloExportloOpenloWriteloReadloSeekloTell loTruncateloCloseloUnlink NotificationnotificationPidnotificationChannelnotificationDatagetNotificationgetNotificationNonBlockingConstraintViolationCheckViolationUniqueViolationForeignKeyViolationNotNullViolationconstraintViolationconstraintViolationEcatchViolationisSerializationErrorisNoActiveTransactionErrorisFailedTransactionError FromFieldFromRowTransactionModeisolationLevel readWriteModeReadOnly ReadWriteDefaultReadWriteModeIsolationLevel SerializableRepeatableRead ReadCommittedDefaultIsolationLeveldefaultTransactionModedefaultIsolationLeveldefaultReadWriteModewithTransactionwithTransactionSerializablewithTransactionLevelwithTransactionModewithTransactionModeRetryrollbackbegin beginLevel beginMode withSavepoint newSavepointreleaseSavepointrollbackToSavepointrollbackToAndReleaseSavepoint executeManyexecutequery_query getTypeInfo fromField FieldParser ResultErrorConversionFailedUnexpectedNull Incompatible errSQLTypeerrSQLTableOid errSQLFielderrHaskellType errMessagetypenametypeInfo typeInfoByOidtableOid tableColumnformat fromJSONField returnError HStoreMap HStoreList HStoreText ToHStoreText toHStoreText HStoreBuilderToHStoretoHStore toBuildertoLazyByteStringhstorefromRow fieldWithfieldnumFieldsRemaining FoldOptions fetchQuantitytransactionMode FetchQuantityFixed Automatic FormatError fmtMessagefmtQuery fmtParams formatQuery formatMany returningfolddefaultFoldOptionsfoldWithOptionsfold_foldWithOptions_forEachforEach_ CopyOutResult CopyOutDone CopyOutRowcopycopy_ getCopyData putCopyData putCopyEnd putCopyErrorppad2pad4++ getUnboundeddecimaltoNumdigitdigits showSecondspad6showD6pad3showD3$fReadUnbounded$fShowUnboundedsqlExp minimizeSpace Data.StringIsStringbytestring-0.10.0.2Data.ByteString.Internal ByteString $fMonoidQuery$fIsStringQuery $fReadQuery $fShowQuery$fEqNullghc-prim GHC.Types getTypoid aeson-0.6.2.0Data.Aeson.Types.InternalValueData.Aeson.Types.ClasstoJSON renderNull$fToFieldValue$fToFieldVector$fToFieldUnbounded$fToFieldUnbounded0$fToFieldUnbounded1$fToFieldUnbounded2$fToFieldTimeOfDay $fToFieldDay$fToFieldLocalTime$fToFieldZonedTime$fToFieldUTCTime $fToFieldText $fToField[]$fToFieldText0$fToFieldByteString$fToFieldByteString0$fToFieldBinary$fToFieldBinary0$fToFieldDouble$fToFieldFloat $fToFieldOid$fToFieldWord64 $fToFieldWord$fToFieldWord32$fToFieldWord16$fToFieldWord8$fToFieldInteger$fToFieldInt64 $fToFieldInt$fToFieldInt32$fToFieldInt16 $fToFieldInt8 $fToFieldBool $fToFieldNull $fToFieldIn$fToFieldMaybe$fToFieldAction $fShowAction $fToRow:. $fToRow[]$fToRow(,,,,,,,,,)$fToRow(,,,,,,,,)$fToRow(,,,,,,,)$fToRow(,,,,,,)$fToRow(,,,,,) $fToRow(,,,,) $fToRow(,,,) $fToRow(,,) $fToRow(,) $fToRowOnly $fToRow()$fEqOk$fExceptionManyErrors $fMonadOk $fMonadPlusOk$fAlternativeOk$fApplicativeOk$fMonadPlusConversion$fMonadConversion$fAlternativeConversion$fApplicativeConversion$fFunctorConversion$fExceptionQueryError$fExceptionSqlErrorliftPQ Data.MaybeNothing convertNotice scanTillQuoteparseQ1parseQ2 parseMaybe isSqlState$fExceptionConstraintViolationmaskGHC.IO Data.Monoid<>unsafeDupablePerformIO getTypeInfo' getAttInfosResultData.ByteStringfromJSONData.Typeable.InternalTypeable$fFromFieldValue$fFromFieldVector$fFromFieldEither Data.EitherRight$fFromFieldUnbounded$fFromFieldUnbounded0$fFromFieldUnbounded1$fFromFieldUnbounded2$fFromFieldTimeOfDay$fFromFieldDay$fFromFieldLocalTime$fFromFieldZonedTime$fFromFieldUTCTime $fFromField[]$fFromFieldText$fFromFieldText0$fFromFieldBinary$fFromFieldBinary0$fFromFieldByteString$fFromFieldOid$fFromFieldByteString0$fFromFieldRatio$fFromFieldDouble$fFromFieldFloat$fFromFieldInteger$fFromFieldInt64$fFromFieldInt$fFromFieldInt32$fFromFieldInt16$fFromFieldChar$fFromFieldBool$fFromFieldNull$fFromFieldMaybe $fFromField()CompatleftunBinary unescapeByteaff fromArrayokTextokText'okBinaryok16ok32ok64okInt doFromFieldatto$fExceptionResultError$fFromFieldHStoreList$fToHStoreHStoreList$fToHStoreTextByteString$fToHStoreTextByteString0CommaEmpty escapeAppend parseHStoreparseHStoreKeyValskipWhiteSpaceparseHStoreTextparseHStoreTexts$fFromFieldHStoreMap$fToFieldHStoreMap$fToHStoreHStoreMap$fToFieldHStoreList$fToFieldHStoreBuilder$fToHStoreTextText$fToHStoreTextText0$fToHStoreTextHStoreText$fMonoidHStoreBuilder$fToHStoreHStoreBuildergetvaluenfieldsgetTypeInfoByColgetTypenameByColellipsis $fFromRow:.$fFromRowVector $fFromRow[]$fFromRow(,,,,,,,,,)$fFromRow(,,,,,,,,)$fFromRow(,,,,,,,)$fFromRow(,,,,,,)$fFromRow(,,,,,)$fFromRow(,,,,)$fFromRow(,,,) $fFromRow(,,) $fFromRow(,) $fFromRowOnly parseTemplateescapeStringConnescapeByteaConn checkError buildQuerydoFoldforM' finishQueryfmtError$fExceptionFormatErrordoCopydoCopyIngetCopyCommandTag