\B>D      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789 : ; < = > ? @ A B C NoneXDEFGHIDEGHDEFGHIGH2015 Dylan SimonNone(23468=KM1Generic class of composite (row or record) types.A  PGColumn t a4 instance describes how te decode a PostgreSQL type t to a.7Decode the PostgreSQL text representation into a value.[Decode the PostgreSQL binary representation into a value. Only needs to be implemented if   is true.A PGParameter t a4 instance describes how to encode a PostgreSQL type t from a.3Encode a value to a PostgreSQL text representation. gEncode a value to a (quoted) literal value for use in SQL statements. Defaults to a quoted version of  _Encode a value to a PostgreSQL representation. Defaults to the text representation by pgEncode A valid PostgreSQL type. This is just an indicator class: no implementation is needed. Unfortunately this will generate orphan instances wherever used. 0Does this type support binary decoding? If so,  must be implemented for every  instance of this type.kA proxy type for PostgreSQL types. The type argument should be an (internal) name of a database type (see \dT+).Parameters that affect how marshalling happens. Currenly we force all other relevant parameters at connect time. Nothing values represent unknown.If integer_datetimes is on$; only relevant for binary encoding.HA list of (nullable) data values, e.g. a single row or query parameters.3A value passed to or from PostgreSQL in raw format.9Special binary-encoded data. Not supported in all cases.AThe standard text encoding format (also used for unknown formats)aFinal parameter encoding function used when a (nullable) parameter is passed to a prepared query.sFinal parameter escaping function used when a (nullable) parameter is passed to be substituted into a simple query.@Final column decoding function used for a nullable result value.DFinal column decoding function used for a non-nullable result value.TProduce a SQL string literal by wrapping (and escaping) a string with single quotes.!Double-quote a value if it's "", "null", or contains any whitespace, '"', '\', or the characters given in the first argument. Checking all these things may not be worth it. We could just double-quote everything."Parse double-quoted values ala !.J1The generic anonymous record type, as created by ROW. In this case we can not know the types, and in fact, PostgreSQL does not accept values of this type regardless (except as literals).KHigh-precision representation of Rational as numeric. Unfortunately, numeric has an NaN, while Rational does not. NaN numeric values will produce exceptions.LRepresentation of DiffTime as interval. PostgreSQL stores months and days separately in intervals, but DiffTime does not. We collapse all interval fields into secondsMN OPQ !"RSTUVWXYZ[\J]^_`abcdKefLghijklmnopqrstuvwxyz{|}~#  !"#  !" pMN  OPQ !"RSTUVWXYZ[\J]^_`abcdKefLghijklmnopqrstuvwxyz{|}~2015 Dylan SimonNone (12468FM#~Represents canonical/default PostgreSQL representation for various Haskell types, allowing convenient type-driven marshalling.(NProduce a safely type-cast literal value for interpolation in a SQL statement.)ACreate an expression that literally substitutes each instance of ${expr} for the result of pgSafeLiteral expr. This lets you do safe, type-driven literal substitution into SQL fragments without needing a full query, bypassing placeholder inference and any prepared queries. Unlike most other TH functions, this does not require any database connection.#$%&'()#$%&'()#$%&'()#$%&'()2015 Dylan SimonNone(2468*YClass indicating that the first PostgreSQL type is an array of the second. This implies  and V instances that will work for any type using comma as a delimiter (i.e., anything but box2). This will only work with 1-dimensional arrays.,0The character used as a delimeter. The default ,+ is correct for all standard types (except box).-The cannonical representation of a PostgreSQL array of any type, which may always contain NULLs. Currenly only one-dimetional arrays are supported, although in PostgreSQL, any array may be of any dimentionality.*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*+,--*+,~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2015 Dylan SimonNone(2468BFXClass indicating that the first PostgreSQL type is a range of the second. This implies  and ' instances that will work for any type.uA end-point for a range, which may be nothing (infinity, NULL in PostgreSQL), open (inclusive), or closed (exclusive)True! if the range includes this boundEquivalent to Bounded False Infinity$Unbounded endpoints are always open.Construct from parts: (makeBound (boundClosed b) (bound b) == bEmpty ranges treated as Empty ranges treated as Equivalent to boundClosed . lowerBoundEquivalent to boundClosed . upperBoundCreate a point range [x,x]Extract a point: getPoint (point x) == Just x6 for discrete (non-continuous) range types, using the  instanceContains rangeContains rangeContains element%The constraint is only necessary for minBound, unfortunatelyWTakes into account open vs. closed (but does not understand equivalent discrete bounds)%The constraint is only necessary for maxBound, unfortunatelyWTakes into account open vs. closed (but does not understand equivalent discrete bounds)@*@32015 Dylan SimonNone(2468  None(+F"+PGException is thrown upon encountering an N with severity of ERROR, FATAL, or PANIC. It holds the message of the error.SPGBackendMessage represents a PostgreSQL protocol message that we'll receive. See  Phttp://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.A RowDescription contains the name, type, table OID, and column number of the resulting columns(s) of a query. The column number is useful for inferring nullability.A ParameterDescription describes the type of a given SQL query/statement parameter ($1, $2, etc.). Unfortunately, PostgreSQL does not give us nullability information for the parameter.(An ErrorResponse contains the severity, SQLSTATE#, and message of an error. See  Mhttp://www.postgresql.org/docs/current/interactive/protocol-error-fields.html.Each DataRow (result of a query) is a list of ByteStrings (or just Nothing for null values, to distinguish them from emtpy strings). The ByteStrings can then be converted to the appropriate type by pgStringToType.CommandComplete is bare for now, although it could be made to contain the number of rows affected by statements in a later version.QPGFrontendMessage represents a PostgreSQL protocol message that we'll send. See  Phttp://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.RSimpleQuery takes a simple SQL string. Parameters ($1, $2, etc.) aren't allowed.*Parse SQL Destination (prepared statement)WDescribe a SQL query/statement. The SQL string can contain parameters ($1, $2, etc.).An established connection to the PostgreSQL server. These objects are not thread-safe and must only be used for a single request at a time.>Information for how to connect to a database, to be passed to .The hostname (ignored if  is )The port, likely either PortNumber 5432 or UnixSocket "/tmp/.s.PGSQL.5432"The name of the database !Log all low-level server messages )How to log server notice messages (e.g., print . PGError)8Produce a human-readable string representing the message Message SQLState code. See  Dhttp://www.postgresql.org/docs/current/static/errcodes-appendix.html.BA database connection with sane defaults: localhost:5432:postgrestConvert a string to a NULL-terminated UTF-8 string. The PostgreSQL protocol transmits most strings in this format.?Given a message, determinal the (optional) type ID and the body)Send a message to PostgreSQL (low-level).Parse an incoming message.iReceive the next message from PostgreSQL (low-level). Note that this will block until it gets a message.Connect to a PostgreSQL server..Disconnect cleanly from the PostgreSQL server.Possibly re-open a connection to a different database, either reusing the connection if the given database is already connected or closing it and opening a new one. Regardless, the input connection must not be used afterwards. Describe a SQL statement/query. A statement description consists of 0 or more parameter descriptions (a PostgreSQL type) and zero or more result field descriptions (for queries) (consist of the name of the field, the type of the field, and a nullability indicator).;A simple query is one which requires sending only a single  message to the PostgreSQL server. The query is sent as a single string; you cannot bind parameters. Note that queries can return 0 results (an empty list).Prepare a statement, bind it, and execute it. If the given statement has already been prepared (and not yet closed) on this connection, it will be re-used.Like | but requests results lazily in chunks of the given size. Does not use a named portal, so other requests may not intervene.1Close a previously prepared query (if necessary).q          a handle from  SQL stringOptional type specifications1Guess nullability, otherwise assume everything is_a list of parameter types, and a list of result field names, types, and nullability indicators. SQL string5The number of rows affected and a list of result rowsSQL statement with placeholders7Optional type specifications (only used for first call)"Paremeters to bind to placeholders*Requested binary format for result columns*Chunk size (1 is common, 0 is all-at-once)          ,           2015 Dylan SimonNone(3FM FA particular PostgreSQL type, identified by full formatted name (from  format_type or \dT). Generate a & based on the environment variables: TPG_HOST (localhost); TPG_SOCK or TPG_PORT (5432); TPG_DB or user; TPG_USER or USER (postgres); TPG_PASS ()/Run an action using the Template Haskell state.?Run an action using the Template Haskell PostgreSQL connection. Specify an alternative database to use during compilation. This lets you override the default connection parameters that are based on TPG environment variables. This should be called as a top-level declaration and produces no code. It uses : so is safe to call multiple times with the same database.!Force reloading of all types from the database. This may be needed if you make structural changes to the database during compile-time./Lookup a type name by OID. Error if not found.zLookup a type OID by type name. This is less common and thus less efficient than going the other way. Fail if not found."A type-aware wrapper to #TH expression to encode a  value to a    .$TH expression to decode a     to a ()  value.%TH expression calling  . ! !""#$% !"#$% !"#$% ! !""#$%None23468F&9Flags affecting how and what type of query to build with 6.(&Create a query -- otherwise just call )# to create a string (SQL fragment).)CDisable nullability inference, treating all values as nullable (if # ) or not (if $).*cPrepare and re-use query, binding parameters of the given types (inferring the rest, like PREPARE).+A prepared query that automatically is prepared in the database the first time it is run and bound with new parameters each subsequent time.,gA simple one-shot query that simply substitutes literal representations of parameters for placeholders..bExecute a query and return the number of rows affected (or -1 if not known) and a list of results./Change the raw SQL query stored within this query. This is unsafe because the query has already been type-checked, so any change must not change the number or type of results or placeholders (so adding additional static WHERE or ORDER BY clauses is generally safe). This is useful in cases where you need to construct some part of the query dynamically, but still want to infer the result types.0gExecute a query that does not return results. Return the number of rows affected (or -1 if not known).1-Run a query and return a list of row results.2HMake a simple query directly from a query string, with no type inference3^Make a prepared query directly from a query string and bind parameters, with no type inference4Run a prepared query in lazy mode, where only chunk size rows are requested at a time. If you eventually retrieve all the rows this way, it will be far less efficient than using pgQuery, since every chunk requires an additional round-trip. Although you may safely stop consuming rows early, currently you may not interleave any other database operation while reading rows. (This limitation could theoretically be lifted if required.)%4Given a SQL statement with placeholders of the form ${expr}0, return a (hopefully) valid SQL statement with $N placeholders and the list of expressions. This does not understand strings or other SQL syntax, so any literal occurrence of the string ${ must be escaped as $${(. Embedded expressions may not contain { or }.&4Given a SQL statement with placeholders of the form $N and a list of TH ' expressions, return a new ' expression that substitutes the expressions for the placeholders. This does not understand strings or other SQL syntax, so any literal occurrence of a string like $N must be escaped as $$N.5& for a default (simple) query.6 Construct a - from a SQL string.7^Parse flags off the beginning of a query string, returning the flags and the remaining string.8!A quasi-quoter for PGSQL queries.=Used in expression context, it may contain any SQL statement [pgSQL|SELECT ...|]<. The statement may contain PostgreSQL-style placeholders ($1, $2 , ...) or in-line placeholders (${1+1}2) containing any valid Haskell expression (except {}). It will be replaced by a -J object that can be used to perform the SQL statement. If there are more $Nr placeholders than expressions, it will instead be a function accepting the additional parameters and returning a -.Note that all occurrences of $N or ${ will be treated as placeholders, regardless of their context in the SQL (e.g., even within SQL strings or other places placeholders are disallowed by PostgreSQL), which may cause invalid SQL or other errors. If you need to pass a literal $> through in these contexts, you may double it to escape it as $$N or $${.TThe statement may start with one of more special flags affecting the interpretation: ?YTo disable nullability inference, treating all result values as nullable, thus returning Y values regardless of inferred nullability. This makes unexpected NULL errors impossible.!@To disable nullability inference, treating all result values as not nullable, thus only returning C where requested. This is makes unexpected NULL errors more likely.$ To create a + rather than a ,', by default inferring parameter types. $(type,...)3To specify specific types to a prepared query (see  >http://www.postgresql.org/docs/current/static/sql-prepare.html for details).#Only do literal ${} substitution using )" and return a string, not a query.8 can also be used at the top-level to execute SQL statements at compile-time (without any parameters and ignoring results). Here the query can only be prefixed with ! to make errors non-fatal.*&'()*+,()*+,-.-./01/234-Chunk size (1 is common, 0 is all-or-nothing)%&01567238456789:;<&'()*+,-./012345678-./,+23&'()*5768014!&'()*+,()*+,-.-./01/234%&01567238456789:;< 2015 Dylan SimonNone(2469AA type based on a PostgreSQL enum. Automatically instantiated by ;.:CList of all the values in the enum along with their database names.;bCreate a new enum type corresponding to the given PostgreSQL enum type. For example, if you have 'CREATE TYPE foo AS ENUM ('abc', 'DEF');, then !makePGEnum "foo" "Foo" ("Foo_"++) will be equivalent to: Edata Foo = Foo_abc | Foo_DEF deriving (Eq, Ord, Enum, Bounded, Typeable) instance Show Foo where show Foo_abc = "abc" ... instance PGType "foo" instance PGParameter "foo" Foo where ... instance PGColumn "foo" Foo where ... instance PGRep "foo" Foo instance PGEnum Foo where pgEnumValues = [(Foo_abc, "abc"), (Foo_DEF, "DEF")]vRequires language extensions: TemplateHaskell, FlexibleInstances, MultiParamTypeClasses, DeriveDataTypeable, DataKinds9:;PostgreSQL enum type nameHaskell type to create9How to generate constructor names from enum values, e.g.  ("Type_"++)9:;9:;9:; None= Convert a ><-style string with placeholders into a new style SQL string.= GqueryTuples :: String -> (PGConnection -> IO [(column1, column2, ...)])EQuery a PostgreSQL server and return the results as a list of tuples.Example (where h is a handle from C): ^$(queryTuples "SELECT usesysid, usename FROM pg_user") h :: IO [(Maybe String, Maybe Integer)]> LqueryTuple :: String -> (PGConnection -> IO (Maybe (column1, column2, ...)))Convenience function to query a PostgreSQL server and return the first result as a tuple. If the query produces no results, return >.Example (where h is a handle from C): let sysid = 10::Integer; $(queryTuple "SELECT usesysid, usename FROM pg_user WHERE usesysid = {sysid}") h :: IO (Maybe (Maybe String, Maybe Integer))? ,execute :: String -> (PGConnection -> IO ())EConvenience function to execute a statement on the PostgreSQL server.Example (where h is a handle from C):@Run a sequence of IO actions (presumably SQL statements) wrapped in a transaction. Unfortunately you're restricted to using this in the ?" Monad for now due to the use of @. I'm debating adding a  MonadPeelIO version.ARoll back a transaction.B9Ignore duplicate key errors. This is also limited to the ? Monad. <==>?@ABCthe host to connect tothe port to connect onthe database to connect tothe username to connect asthe password to connect with5a handle to communicate with the PostgreSQL server on <=>?@ABC =>?B@A<C <==>?@ABCNone     018     810A !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !!"#$%&'()*+,-../0123456789:;<=>? @ A B C D E F G H I  J K L M N OPQRST"$UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !""#$%&'()*+)*,-./011223456789:;<=>?@A B C)*DEFGpostgresql-typed-0.3.3Database.PostgreSQL.Typed.Types!Database.PostgreSQL.Typed.DynamicDatabase.PostgreSQL.Typed.ArrayDatabase.PostgreSQL.Typed.RangeDatabase.PostgreSQL.Typed.Inet"Database.PostgreSQL.Typed.ProtocolDatabase.PostgreSQL.Typed.THDatabase.PostgreSQL.Typed.QueryDatabase.PostgreSQL.Typed.Enum$Database.PostgreSQL.Typed.TemplatePG"Database.PostgreSQL.Typed.InternalL ByteStringDatabase.PostgreSQL.TypedPGRecordOIDPGColumnpgDecodepgDecodeBinary pgDecodeValue PGParameterpgEncode pgLiteral pgEncodeValuePGType pgTypeNamepgBinaryColumn PGTypeName PGTypeProxy PGTypeEnvpgIntegerDatetimesPGValuesPGValue PGBinaryValue pgBinaryValue PGTextValue pgTextValue PGNullValueunknownPGTypeEnvpgEncodeParameterpgEscapeParameterpgDecodeColumnpgDecodeColumnNotNullpgQuote buildPGValuepgDQuote parsePGDQuotePGReppgTypeOf pgEncodeRep pgLiteralRep pgDecodeRep pgSafeLiteralpgSubstituteLiterals PGArrayTypepgArrayElementType pgArrayDelimPGArray%$fPGArrayType"int8range[]""int8range"$fPGType"int8range[]"%$fPGArrayType"daterange[]""daterange"$fPGType"daterange[]"%$fPGArrayType"tstzrange[]""tstzrange"$fPGType"tstzrange[]"!$fPGArrayType"tsrange[]""tsrange"$fPGType"tsrange[]"#$fPGArrayType"numrange[]""numrange"$fPGType"numrange[]"%$fPGArrayType"int4range[]""int4range"$fPGType"int4range[]"-$fPGArrayType"regdictionary[]""regdictionary"$fPGType"regdictionary[]"%$fPGArrayType"regconfig[]""regconfig"$fPGType"regconfig[]"%$fPGArrayType"gtsvector[]""gtsvector"$fPGType"gtsvector[]"!$fPGArrayType"tsquery[]""tsquery"$fPGType"tsquery[]"#$fPGArrayType"tsvector[]""tsvector"$fPGType"tsvector[]"-$fPGArrayType"txid_snapshot[]""txid_snapshot"$fPGType"txid_snapshot[]"$fPGArrayType"uuid[]""uuid"$fPGType"uuid[]"!$fPGArrayType"cstring[]""cstring"$fPGType"cstring[]"$fPGArrayType"record[]""record"$fPGType"record[]"!$fPGArrayType"regtype[]""regtype"$fPGType"regtype[]"#$fPGArrayType"regclass[]""regclass"$fPGType"regclass[]")$fPGArrayType"regoperator[]""regoperator"$fPGType"regoperator[]"!$fPGArrayType"regoper[]""regoper"$fPGType"regoper[]"+$fPGArrayType"regprocedure[]""regprocedure"$fPGType"regprocedure[]"%$fPGArrayType"refcursor[]""refcursor"$fPGType"refcursor[]"!$fPGArrayType"numeric[]""numeric"$fPGType"numeric[]"$fPGArrayType"varbit[]""varbit"$fPGType"varbit[]"$fPGArrayType"bit[]""bit"$fPGType"bit[]"9$fPGArrayType"time with time zone[]""time with time zone"$fPGType"time with time zone[]"#$fPGArrayType"interval[]""interval"$fPGType"interval[]"C$fPGArrayType"timestamp with time zone[]""timestamp with time zone"$$fPGType"timestamp with time zone[]"I$fPGArrayType"timestamp without time zone[]""timestamp without time zone"'$fPGType"timestamp without time zone[]"?$fPGArrayType"time without time zone[]""time without time zone""$fPGType"time without time zone[]"$fPGArrayType"date[]""date"$fPGType"date[]"5$fPGArrayType"character varying[]""character varying"$fPGType"character varying[]"$fPGArrayType"bpchar[]""bpchar"$fPGType"bpchar[]"!$fPGArrayType"aclitem[]""aclitem"$fPGType"aclitem[]"$fPGArrayType"inet[]""inet"$fPGType"inet[]"!$fPGArrayType"macaddr[]""macaddr"$fPGType"macaddr[]"$fPGArrayType"money[]""money"$fPGType"money[]"$fPGArrayType"circle[]""circle"$fPGType"circle[]"%$fPGArrayType"tinterval[]""tinterval"$fPGType"tinterval[]"!$fPGArrayType"reltime[]""reltime"$fPGType"reltime[]"!$fPGArrayType"abstime[]""abstime"$fPGType"abstime[]"3$fPGArrayType"double precision[]""double precision"$fPGType"double precision[]"$fPGArrayType"real[]""real"$fPGType"real[]"$fPGArrayType"cidr[]""cidr"$fPGType"cidr[]"$fPGArrayType"line[]""line"$fPGType"line[]"!$fPGArrayType"polygon[]""polygon"$fPGType"polygon[]"$fPGArrayType"box[]""box"$fPGType"box[]"$fPGArrayType"path[]""path"$fPGType"path[]"$fPGArrayType"lseg[]""lseg"$fPGType"lseg[]"$fPGArrayType"point[]""point"$fPGType"point[]"$fPGArrayType"xml[]""xml"$fPGType"xml[]"$fPGArrayType"json[]""json"$fPGType"json[]"%$fPGArrayType"oidvector[]""oidvector"$fPGType"oidvector[]"$fPGArrayType"cid[]""cid"$fPGType"cid[]"$fPGArrayType"xid[]""xid"$fPGType"xid[]"$fPGArrayType"tid[]""tid"$fPGType"tid[]"$fPGArrayType"oid[]""oid"$fPGType"oid[]"$fPGArrayType"text[]""text"$fPGType"text[]"!$fPGArrayType"regproc[]""regproc"$fPGType"regproc[]"!$fPGArrayType"integer[]""integer"$fPGType"integer[]"'$fPGArrayType"int2vector[]""int2vector"$fPGType"int2vector[]"#$fPGArrayType"smallint[]""smallint"$fPGType"smallint[]"$fPGArrayType"bigint[]""bigint"$fPGType"bigint[]"$fPGArrayType"name[]""name"$fPGType"name[]"#$fPGArrayType"\"char\"[]""\"char\""$fPGType"\"char\"[]"$fPGArrayType"bytea[]""bytea"$fPGType"bytea[]"!$fPGArrayType"boolean[]""boolean"$fPGType"boolean[]"$fPGColumnta[]$fPGParameterta[] PGRangeTypepgRangeElementTypeRangelowerupperEmpty UpperBoundUpper boundUpper LowerBoundLower boundLowerBoundBounded _boundClosed_bound Unbounded compareBoundsbound boundClosed makeBound lowerBound upperBound lowerClosed upperClosedemptyisEmptyfullisFullpointgetPointrangenormalbounded normalize normalize'@><@@>.overlaps intersect $fPGRangeType"int8range""bigint"$fPGType"int8range"$fPGRangeType"daterange""date"$fPGType"daterange"2$fPGRangeType"tstzrange""timestamp with time zone"$fPGType"tstzrange"3$fPGRangeType"tsrange""timestamp without time zone"$fPGType"tsrange" $fPGRangeType"numrange""numeric"$fPGType"numrange"!$fPGRangeType"int4range""integer"$fPGType"int4range"$fPGColumntrRange$fPGParametertrRange $fMonoidRange $fShowRange$fFunctorRange$fBoundedUpperBound$fOrdUpperBound$fBoundedLowerBound$fOrdLowerBound$fFunctorBoundPGInetPGInet6 pgInetAddr6 pgInetAddr pgInetMasksockAddrPGInet$fPGParameter"cidr"PGInet$fPGParameter"inet"PGInet$fPGType"cidr"$fPGType"inet" $fShowPGInetPGError pgErrorFields PGConnection PGDatabasepgDBHostpgDBPortpgDBNamepgDBUserpgDBPass pgDBDebugpgDBLogMessage pgErrorCodedefaultPGDatabase pgTypeEnv pgConnect pgDisconnect pgReconnect pgDescribe pgSimpleQuerypgPreparedQuerypgPreparedLazyQuerypgCloseStatement TPGValueInfo tpgValueNametpgValueTypeOID tpgValueTypetpgValueNullablegetTPGDatabasewithTPGConnectionuseTPGDatabasereloadTPGTypes tpgDescribetpgTypeEncodertpgTypeDecoder tpgTypeBinary QueryFlags flagQuery flagNullable flagPreparePGPreparedQuery PGSimpleQueryPGQuery pgRunQueryunsafeModifyQuery pgExecutepgQueryrawPGSimpleQueryrawPGPreparedQuery pgLazyQuerysimpleQueryFlags makePGQueryparseQueryFlagspgSQLPGEnum pgEnumValues makePGEnum PGException queryTuples queryTupleexecutewithTransactionrollback insertIgnorestringEStringEInfixE$++$++$ $fIsStringExp$fPGRecordType"record"$fPGColumn"numeric"Ratio$fPGColumn"interval"DiffTime PGRecordType PGStringType pgQuoteUnsafe encodeBytea decodeByteabinColDatetimefixTZ showRational$fPGColumn"jsonb"Value$fPGParameter"jsonb"Value$fPGType"jsonb"$fPGColumn"json"Value$fPGParameter"json"Value$fPGType"json"$fPGType"record"$fPGColumntPGRecord$fPGParametertPGRecord$fPGColumn"uuid"UUID$fPGParameter"uuid"UUID$fPGType"uuid"$fPGColumn"numeric"Scientific $fPGParameter"numeric"Scientific$fPGParameter"numeric"Ratio$fPGType"numeric"$fPGParameter"interval"DiffTime$fPGType"interval"+$fPGColumn"timestamp with time zone"UTCTime.$fPGParameter"timestamp with time zone"UTCTime"$fPGType"timestamp with time zone"0$fPGColumn"timestamp without time zone"LocalTime3$fPGParameter"timestamp without time zone"LocalTime%$fPGType"timestamp without time zone"+$fPGColumn"time without time zone"TimeOfDay.$fPGParameter"time without time zone"TimeOfDay $fPGType"time without time zone"$fPGColumn"date"Day$fPGParameter"date"Day$fPGType"date"$fPGColumn"bytea"ByteString$fPGParameter"bytea"ByteString$fPGColumn"bytea"ByteString0$fPGParameter"bytea"ByteString0$fPGType"bytea"$fPGStringType"bpchar"$fPGStringType"name"!$fPGStringType"character varying"$fPGStringType"text"$fPGType"bpchar"$fPGType"name"$fPGType"character varying"$fPGType"text"$fPGColumntText$fPGParametertText$fPGColumntText0$fPGParametertText0$fPGColumntByteString$fPGParametertByteString$fPGColumntByteString0$fPGParametertByteString0 $fPGColumnt[]$fPGParametert[]$fPGColumn"\"char\""Char$fPGParameter"\"char\""Char$fPGType"\"char\"""$fPGColumn"double precision"Double%$fPGParameter"double precision"Double$fPGType"double precision"$fPGColumn"real"Float$fPGParameter"real"Float$fPGType"real"$fPGColumn"bigint"Int64$fPGParameter"bigint"Int64$fPGType"bigint"$fPGColumn"integer"Int32$fPGParameter"integer"Int32$fPGType"integer"$fPGColumn"smallint"Int16$fPGParameter"smallint"Int16$fPGType"smallint"$fPGColumn"oid"Word32$fPGParameter"oid"Word32 $fPGType"oid"$fPGColumn"boolean"Bool$fPGParameter"boolean"Bool$fPGType"boolean"$fPGColumn"void"()$fPGType"void"$fPGColumntMaybe$fPGParametertMaybe$fPGRep"uuid"UUID$fPGRep"numeric"Scientific$fPGRep"numeric"Ratio$fPGRep"interval"DiffTime($fPGRep"timestamp with time zone"UTCTime-$fPGRep"timestamp without time zone"LocalTime($fPGRep"time without time zone"TimeOfDay$fPGRep"date"Day$fPGRep"text"Text$fPGRep"text"[]$fPGRep"\"char\""Char$fPGRep"double precision"Double$fPGRep"real"Float$fPGRep"bigint"Int64$fPGRep"integer"Int32$fPGRep"smallint"Int16$fPGRep"oid"Word32$fPGRep"boolean"Bool $fPGReptMaybebaseGHC.EnumEnum ErrorResponsePGBackendMessageRowDescriptionParameterDescriptionDataRowCommandCompletePGFrontendMessage SimpleQueryParseDescribenetwork-2.6.1.0Network UnixSocketdisplayMessagepgString messageBodypgSendgetMessageBody pgReceive ReadyForQueryPortalSuspended ParseCompleteParameterStatusNoticeResponseNoData messageFieldsEmptyQueryResponse CloseComplete BindCompleteBackendKeyDataAuthenticationMD5PasswordAuthenticationCleartextPasswordAuthenticationOk TerminateSyncPasswordMessage queryString parseTypesFlushExecuteCloseBind statementNamebindParameters binaryColumns CancelRequestStartupMessage MessageFieldsColDescriptioncolNamecolTable colNumbercolType colModifier colBinary connHandle connDatabaseconnPidconnKeyconnParameters connTypeEnvconnPreparedStatements connState connInputPGState StateClosedStateTransactionFailedStateTransaction StateIdle StatePending StateUnknown makeMessagedefaultLogMessage connDebugconnLogMessagemd5nulpgFlush getPGStringgetByteStringNulgetMessageFields getMessagepgRecvpgSync rowsAffected fixBinarypgPreparedBind$fExceptionPGError $fShowPGError$fEqPGDatabaseTPGType withTPGStatetpgType getTPGTypeOID Data.MaybeMaybeTPGState tpgConnectiontpgTypestpgState tpgLoadTypestpgInit typeApplyghc-prim GHC.TypesTrueFalsesqlPlaceholders sqlSubstituteGHC.BaseString QueryParser PreparedQuery PGRawQuery rawParser splitCommastrimqqQueryqqTop$fIsStringQueryParser$fIsStringQueryParser0$fFunctorQueryParser$fPGQueryQueryParsera$fPGRawQueryPreparedQuery$fPGQueryPreparedQuery[]$fPGRawQuerySimpleQuery$fPGQuerySimpleQuery[] $fPGQuery[][]querySQLNothingIOControl.Exception.Base onException