h&]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                           Safe-Inferred"Upostgresql-typedSUCCESSFUL_COMPLETION: 00000 (Success)postgresql-typedWARNING: 01000 (Warning)postgresql-typed$WARNING_DYNAMIC_RESULT_SETS_RETURNED: 0100C (Warning)postgresql-typed!WARNING_IMPLICIT_ZERO_BIT_PADDING: 01008 (Warning)postgresql-typed-WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION: 01003 (Warning)postgresql-typedWARNING_PRIVILEGE_NOT_GRANTED: 01007 (Warning)postgresql-typedWARNING_PRIVILEGE_NOT_REVOKED: 01006 (Warning)postgresql-typed$WARNING_STRING_DATA_RIGHT_TRUNCATION: 01004 (Warning)postgresql-typedWARNING_DEPRECATED_FEATURE: 01P01 (Warning) postgresql-typedNO_DATA: 02000 (Warning) postgresql-typed*NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED: 02001 (Warning) postgresql-typedSQL_STATEMENT_NOT_YET_COMPLETE: 03000 (Error) postgresql-typedCONNECTION_EXCEPTION: 08000 (Error) postgresql-typedCONNECTION_DOES_NOT_EXIST: 08003 (Error)postgresql-typedCONNECTION_FAILURE: 08006 (Error)postgresql-typed+SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION: 08001 (Error)postgresql-typed1SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION: 08004 (Error)postgresql-typedTRANSACTION_RESOLUTION_UNKNOWN: 08007 (Error)postgresql-typedPROTOCOL_VIOLATION: 08P01 (Error)postgresql-typedTRIGGERED_ACTION_EXCEPTION: 09000 (Error)postgresql-typedFEATURE_NOT_SUPPORTED: 0A000 (Error)postgresql-typedINVALID_TRANSACTION_INITIATION: 0B000 (Error)postgresql-typedLOCATOR_EXCEPTION: 0F000 (Error)postgresql-typedL_E_INVALID_SPECIFICATION: 0F001 (Error)postgresql-typedINVALID_GRANTOR: 0L000 (Error)postgresql-typedINVALID_GRANT_OPERATION: 0LP01 (Error)postgresql-typedINVALID_ROLE_SPECIFICATION: 0P000 (Error)postgresql-typedDIAGNOSTICS_EXCEPTION: 0Z000 (Error)postgresql-typed3STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER: 0Z002 (Error)postgresql-typedCASE_NOT_FOUND: 20000 (Error)postgresql-typedCARDINALITY_VIOLATION: 21000 (Error)postgresql-typedDATA_EXCEPTION: 22000 (Error) postgresql-typedARRAY_ELEMENT_ERROR: 2202E (Error)!postgresql-typedARRAY_SUBSCRIPT_ERROR: 2202E (Error)"postgresql-typedCHARACTER_NOT_IN_REPERTOIRE: 22021 (Error)#postgresql-typedDATETIME_FIELD_OVERFLOW: 22008 (Error)$postgresql-typedDATETIME_VALUE_OUT_OF_RANGE: 22008 (Error)%postgresql-typedDIVISION_BY_ZERO: 22012 (Error)&postgresql-typedERROR_IN_ASSIGNMENT: 22005 (Error)'postgresql-typedESCAPE_CHARACTER_CONFLICT: 2200B (Error)(postgresql-typedINDICATOR_OVERFLOW: 22022 (Error))postgresql-typedINTERVAL_FIELD_OVERFLOW: 22015 (Error)*postgresql-typedINVALID_ARGUMENT_FOR_LOG: 2201E (Error)+postgresql-typedINVALID_ARGUMENT_FOR_NTILE: 22014 (Error),postgresql-typedINVALID_ARGUMENT_FOR_NTH_VALUE: 22016 (Error)-postgresql-typed#INVALID_ARGUMENT_FOR_POWER_FUNCTION: 2201F (Error).postgresql-typed*INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION: 2201G (Error)/postgresql-typed INVALID_CHARACTER_VALUE_FOR_CAST: 22018 (Error)0postgresql-typedINVALID_DATETIME_FORMAT: 22007 (Error)1postgresql-typedINVALID_ESCAPE_CHARACTER: 22019 (Error)2postgresql-typedINVALID_ESCAPE_OCTET: 2200D (Error)3postgresql-typedINVALID_ESCAPE_SEQUENCE: 22025 (Error)4postgresql-typed#NONSTANDARD_USE_OF_ESCAPE_CHARACTER: 22P06 (Error)5postgresql-typed!INVALID_INDICATOR_PARAMETER_VALUE: 22010 (Error)6postgresql-typedINVALID_PARAMETER_VALUE: 22023 (Error)7postgresql-typed#INVALID_PRECEDING_OR_FOLLOWING_SIZE: 22013 (Error)8postgresql-typedINVALID_REGULAR_EXPRESSION: 2201B (Error)9postgresql-typed!INVALID_ROW_COUNT_IN_LIMIT_CLAUSE: 2201W (Error):postgresql-typed)INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE: 2201X (Error);postgresql-typedINVALID_TABLESAMPLE_ARGUMENT: 2202H (Error)<postgresql-typedINVALID_TABLESAMPLE_REPEAT: 2202G (Error)=postgresql-typed$INVALID_TIME_ZONE_DISPLACEMENT_VALUE: 22009 (Error)>postgresql-typedINVALID_USE_OF_ESCAPE_CHARACTER: 2200C (Error)?postgresql-typedMOST_SPECIFIC_TYPE_MISMATCH: 2200G (Error)@postgresql-typedNULL_VALUE_NOT_ALLOWED: 22004 (Error)Apostgresql-typed!NULL_VALUE_NO_INDICATOR_PARAMETER: 22002 (Error)Bpostgresql-typedNUMERIC_VALUE_OUT_OF_RANGE: 22003 (Error)Cpostgresql-typed!SEQUENCE_GENERATOR_LIMIT_EXCEEDED: 2200H (Error)Dpostgresql-typedSTRING_DATA_LENGTH_MISMATCH: 22026 (Error)Epostgresql-typedSTRING_DATA_RIGHT_TRUNCATION: 22001 (Error)Fpostgresql-typedSUBSTRING_ERROR: 22011 (Error)Gpostgresql-typed TRIM_ERROR: 22027 (Error)Hpostgresql-typedUNTERMINATED_C_STRING: 22024 (Error)Ipostgresql-typedZERO_LENGTH_CHARACTER_STRING: 2200F (Error)Jpostgresql-typedFLOATING_POINT_EXCEPTION: 22P01 (Error)Kpostgresql-typedINVALID_TEXT_REPRESENTATION: 22P02 (Error)Lpostgresql-typedINVALID_BINARY_REPRESENTATION: 22P03 (Error)Mpostgresql-typedBAD_COPY_FILE_FORMAT: 22P04 (Error)Npostgresql-typedUNTRANSLATABLE_CHARACTER: 22P05 (Error)Opostgresql-typedNOT_AN_XML_DOCUMENT: 2200L (Error)Ppostgresql-typedINVALID_XML_DOCUMENT: 2200M (Error)Qpostgresql-typedINVALID_XML_CONTENT: 2200N (Error)Rpostgresql-typedINVALID_XML_COMMENT: 2200S (Error)Spostgresql-typed"INVALID_XML_PROCESSING_INSTRUCTION: 2200T (Error)Tpostgresql-typedDUPLICATE_JSON_OBJECT_KEY_VALUE: 22030 (Error)Upostgresql-typedINVALID_JSON_TEXT: 22032 (Error)Vpostgresql-typedINVALID_SQL_JSON_SUBSCRIPT: 22033 (Error)Wpostgresql-typedMORE_THAN_ONE_SQL_JSON_ITEM: 22034 (Error)Xpostgresql-typedNO_SQL_JSON_ITEM: 22035 (Error)Ypostgresql-typedNON_NUMERIC_SQL_JSON_ITEM: 22036 (Error)Zpostgresql-typed NON_UNIQUE_KEYS_IN_A_JSON_OBJECT: 22037 (Error)[postgresql-typed SINGLETON_SQL_JSON_ITEM_REQUIRED: 22038 (Error)\postgresql-typedSQL_JSON_ARRAY_NOT_FOUND: 22039 (Error)]postgresql-typedSQL_JSON_MEMBER_NOT_FOUND: 2203A (Error)^postgresql-typedSQL_JSON_NUMBER_NOT_FOUND: 2203B (Error)_postgresql-typedSQL_JSON_OBJECT_NOT_FOUND: 2203C (Error)`postgresql-typedTOO_MANY_JSON_ARRAY_ELEMENTS: 2203D (Error)apostgresql-typedTOO_MANY_JSON_OBJECT_MEMBERS: 2203E (Error)bpostgresql-typedSQL_JSON_SCALAR_REQUIRED: 2203F (Error)cpostgresql-typedINTEGRITY_CONSTRAINT_VIOLATION: 23000 (Error)dpostgresql-typedRESTRICT_VIOLATION: 23001 (Error)epostgresql-typedNOT_NULL_VIOLATION: 23502 (Error)fpostgresql-typedFOREIGN_KEY_VIOLATION: 23503 (Error)gpostgresql-typedUNIQUE_VIOLATION: 23505 (Error)hpostgresql-typedCHECK_VIOLATION: 23514 (Error)ipostgresql-typedEXCLUSION_VIOLATION: 23P01 (Error)jpostgresql-typedINVALID_CURSOR_STATE: 24000 (Error)kpostgresql-typedINVALID_TRANSACTION_STATE: 25000 (Error)lpostgresql-typedACTIVE_SQL_TRANSACTION: 25001 (Error)mpostgresql-typed!BRANCH_TRANSACTION_ALREADY_ACTIVE: 25002 (Error)npostgresql-typed)HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL: 25008 (Error)opostgresql-typed0INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION: 25003 (Error)ppostgresql-typed4INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION: 25004 (Error)qpostgresql-typed0NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION: 25005 (Error)rpostgresql-typedREAD_ONLY_SQL_TRANSACTION: 25006 (Error)spostgresql-typed.SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED: 25007 (Error)tpostgresql-typedNO_ACTIVE_SQL_TRANSACTION: 25P01 (Error)upostgresql-typedIN_FAILED_SQL_TRANSACTION: 25P02 (Error)vpostgresql-typed#IDLE_IN_TRANSACTION_SESSION_TIMEOUT: 25P03 (Error)wpostgresql-typedINVALID_SQL_STATEMENT_NAME: 26000 (Error)xpostgresql-typedTRIGGERED_DATA_CHANGE_VIOLATION: 27000 (Error)ypostgresql-typed#INVALID_AUTHORIZATION_SPECIFICATION: 28000 (Error)zpostgresql-typedINVALID_PASSWORD: 28P01 (Error){postgresql-typed+DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST: 2B000 (Error)|postgresql-typedDEPENDENT_OBJECTS_STILL_EXIST: 2BP01 (Error)}postgresql-typedINVALID_TRANSACTION_TERMINATION: 2D000 (Error)~postgresql-typedSQL_ROUTINE_EXCEPTION: 2F000 (Error)postgresql-typed+S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT: 2F005 (Error)postgresql-typed&S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED: 2F002 (Error)postgresql-typed(S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED: 2F003 (Error)postgresql-typed$S_R_E_READING_SQL_DATA_NOT_PERMITTED: 2F004 (Error)postgresql-typedINVALID_CURSOR_NAME: 34000 (Error)postgresql-typedEXTERNAL_ROUTINE_EXCEPTION: 38000 (Error)postgresql-typed"E_R_E_CONTAINING_SQL_NOT_PERMITTED: 38001 (Error)postgresql-typed&E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED: 38002 (Error)postgresql-typed(E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED: 38003 (Error)postgresql-typed$E_R_E_READING_SQL_DATA_NOT_PERMITTED: 38004 (Error)postgresql-typed%EXTERNAL_ROUTINE_INVOCATION_EXCEPTION: 39000 (Error)postgresql-typed!E_R_I_E_INVALID_SQLSTATE_RETURNED: 39001 (Error)postgresql-typedE_R_I_E_NULL_VALUE_NOT_ALLOWED: 39004 (Error)postgresql-typed!E_R_I_E_TRIGGER_PROTOCOL_VIOLATED: 39P01 (Error)postgresql-typedE_R_I_E_SRF_PROTOCOL_VIOLATED: 39P02 (Error)postgresql-typed'E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED: 39P03 (Error)postgresql-typedSAVEPOINT_EXCEPTION: 3B000 (Error)postgresql-typedS_E_INVALID_SPECIFICATION: 3B001 (Error)postgresql-typedINVALID_CATALOG_NAME: 3D000 (Error)postgresql-typedINVALID_SCHEMA_NAME: 3F000 (Error)postgresql-typedTRANSACTION_ROLLBACK: 40000 (Error)postgresql-typed"T_R_INTEGRITY_CONSTRAINT_VIOLATION: 40002 (Error)postgresql-typedT_R_SERIALIZATION_FAILURE: 40001 (Error)postgresql-typed T_R_STATEMENT_COMPLETION_UNKNOWN: 40003 (Error)postgresql-typedT_R_DEADLOCK_DETECTED: 40P01 (Error)postgresql-typed%SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION: 42000 (Error)postgresql-typed SYNTAX_ERROR: 42601 (Error)postgresql-typedINSUFFICIENT_PRIVILEGE: 42501 (Error)postgresql-typed CANNOT_COERCE: 42846 (Error)postgresql-typedGROUPING_ERROR: 42803 (Error)postgresql-typedWINDOWING_ERROR: 42P20 (Error)postgresql-typedINVALID_RECURSION: 42P19 (Error)postgresql-typedINVALID_FOREIGN_KEY: 42830 (Error)postgresql-typed INVALID_NAME: 42602 (Error)postgresql-typed NAME_TOO_LONG: 42622 (Error)postgresql-typed RESERVED_NAME: 42939 (Error)postgresql-typedDATATYPE_MISMATCH: 42804 (Error)postgresql-typedINDETERMINATE_DATATYPE: 42P18 (Error)postgresql-typedCOLLATION_MISMATCH: 42P21 (Error)postgresql-typedINDETERMINATE_COLLATION: 42P22 (Error)postgresql-typedWRONG_OBJECT_TYPE: 42809 (Error)postgresql-typedGENERATED_ALWAYS: 428C9 (Error)postgresql-typedUNDEFINED_COLUMN: 42703 (Error)postgresql-typedUNDEFINED_CURSOR: 34000 (Error)postgresql-typedUNDEFINED_DATABASE: 3D000 (Error)postgresql-typedUNDEFINED_FUNCTION: 42883 (Error)postgresql-typedUNDEFINED_PSTATEMENT: 26000 (Error)postgresql-typedUNDEFINED_SCHEMA: 3F000 (Error)postgresql-typedUNDEFINED_TABLE: 42P01 (Error)postgresql-typedUNDEFINED_PARAMETER: 42P02 (Error)postgresql-typedUNDEFINED_OBJECT: 42704 (Error)postgresql-typedDUPLICATE_COLUMN: 42701 (Error)postgresql-typedDUPLICATE_CURSOR: 42P03 (Error)postgresql-typedDUPLICATE_DATABASE: 42P04 (Error)postgresql-typedDUPLICATE_FUNCTION: 42723 (Error)postgresql-typedDUPLICATE_PSTATEMENT: 42P05 (Error)postgresql-typedDUPLICATE_SCHEMA: 42P06 (Error)postgresql-typedDUPLICATE_TABLE: 42P07 (Error)postgresql-typedDUPLICATE_ALIAS: 42712 (Error)postgresql-typedDUPLICATE_OBJECT: 42710 (Error)postgresql-typedAMBIGUOUS_COLUMN: 42702 (Error)postgresql-typedAMBIGUOUS_FUNCTION: 42725 (Error)postgresql-typedAMBIGUOUS_PARAMETER: 42P08 (Error)postgresql-typedAMBIGUOUS_ALIAS: 42P09 (Error)postgresql-typedINVALID_COLUMN_REFERENCE: 42P10 (Error)postgresql-typedINVALID_COLUMN_DEFINITION: 42611 (Error)postgresql-typedINVALID_CURSOR_DEFINITION: 42P11 (Error)postgresql-typedINVALID_DATABASE_DEFINITION: 42P12 (Error)postgresql-typedINVALID_FUNCTION_DEFINITION: 42P13 (Error)postgresql-typedINVALID_PSTATEMENT_DEFINITION: 42P14 (Error)postgresql-typedINVALID_SCHEMA_DEFINITION: 42P15 (Error)postgresql-typedINVALID_TABLE_DEFINITION: 42P16 (Error)postgresql-typedINVALID_OBJECT_DEFINITION: 42P17 (Error)postgresql-typedWITH_CHECK_OPTION_VIOLATION: 44000 (Error)postgresql-typedINSUFFICIENT_RESOURCES: 53000 (Error)postgresql-typed DISK_FULL: 53100 (Error)postgresql-typed OUT_OF_MEMORY: 53200 (Error)postgresql-typedTOO_MANY_CONNECTIONS: 53300 (Error)postgresql-typedCONFIGURATION_LIMIT_EXCEEDED: 53400 (Error)postgresql-typedPROGRAM_LIMIT_EXCEEDED: 54000 (Error)postgresql-typedSTATEMENT_TOO_COMPLEX: 54001 (Error)postgresql-typedTOO_MANY_COLUMNS: 54011 (Error)postgresql-typedTOO_MANY_ARGUMENTS: 54023 (Error)postgresql-typed OBJECT_NOT_IN_PREREQUISITE_STATE: 55000 (Error)postgresql-typed OBJECT_IN_USE: 55006 (Error)postgresql-typedCANT_CHANGE_RUNTIME_PARAM: 55P02 (Error)postgresql-typedLOCK_NOT_AVAILABLE: 55P03 (Error)postgresql-typedUNSAFE_NEW_ENUM_VALUE_USAGE: 55P04 (Error)postgresql-typedOPERATOR_INTERVENTION: 57000 (Error)postgresql-typedQUERY_CANCELED: 57014 (Error)postgresql-typedADMIN_SHUTDOWN: 57P01 (Error)postgresql-typedCRASH_SHUTDOWN: 57P02 (Error)postgresql-typedCANNOT_CONNECT_NOW: 57P03 (Error)postgresql-typedDATABASE_DROPPED: 57P04 (Error)postgresql-typed SYSTEM_ERROR: 58000 (Error)postgresql-typedIO_ERROR: 58030 (Error)postgresql-typedUNDEFINED_FILE: 58P01 (Error)postgresql-typedDUPLICATE_FILE: 58P02 (Error)postgresql-typedSNAPSHOT_TOO_OLD: 72000 (Error)postgresql-typedCONFIG_FILE_ERROR: F0000 (Error)postgresql-typedLOCK_FILE_EXISTS: F0001 (Error)postgresql-typed FDW_ERROR: HV000 (Error)postgresql-typedFDW_COLUMN_NAME_NOT_FOUND: HV005 (Error)postgresql-typed"FDW_DYNAMIC_PARAMETER_VALUE_NEEDED: HV002 (Error)postgresql-typedFDW_FUNCTION_SEQUENCE_ERROR: HV010 (Error)postgresql-typed'FDW_INCONSISTENT_DESCRIPTOR_INFORMATION: HV021 (Error)postgresql-typedFDW_INVALID_ATTRIBUTE_VALUE: HV024 (Error)postgresql-typedFDW_INVALID_COLUMN_NAME: HV007 (Error)postgresql-typedFDW_INVALID_COLUMN_NUMBER: HV008 (Error)postgresql-typedFDW_INVALID_DATA_TYPE: HV004 (Error)postgresql-typed!FDW_INVALID_DATA_TYPE_DESCRIPTORS: HV006 (Error)postgresql-typed'FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER: HV091 (Error)postgresql-typedFDW_INVALID_HANDLE: HV00B (Error)postgresql-typedFDW_INVALID_OPTION_INDEX: HV00C (Error)postgresql-typedFDW_INVALID_OPTION_NAME: HV00D (Error)postgresql-typed*FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH: HV090 (Error)postgresql-typedFDW_INVALID_STRING_FORMAT: HV00A (Error)postgresql-typedFDW_INVALID_USE_OF_NULL_POINTER: HV009 (Error)postgresql-typedFDW_TOO_MANY_HANDLES: HV014 (Error)postgresql-typedFDW_OUT_OF_MEMORY: HV001 (Error)postgresql-typedFDW_NO_SCHEMAS: HV00P (Error)postgresql-typedFDW_OPTION_NAME_NOT_FOUND: HV00J (Error)postgresql-typedFDW_REPLY_HANDLE: HV00K (Error)postgresql-typedFDW_SCHEMA_NOT_FOUND: HV00Q (Error)postgresql-typedFDW_TABLE_NOT_FOUND: HV00R (Error)postgresql-typedFDW_UNABLE_TO_CREATE_EXECUTION: HV00L (Error)postgresql-typedFDW_UNABLE_TO_CREATE_REPLY: HV00M (Error)postgresql-typed"FDW_UNABLE_TO_ESTABLISH_CONNECTION: HV00N (Error)postgresql-typed PLPGSQL_ERROR: P0000 (Error)postgresql-typedRAISE_EXCEPTION: P0001 (Error)postgresql-typed NO_DATA_FOUND: P0002 (Error)postgresql-typed TOO_MANY_ROWS: P0003 (Error)postgresql-typedASSERT_FAILURE: P0004 (Error)postgresql-typedINTERNAL_ERROR: XX000 (Error)postgresql-typedDATA_CORRUPTED: XX001 (Error)postgresql-typedINDEX_CORRUPTED: XX002 (Error)postgresql-typed#All known error code names by code.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2016 Dylan Simon Safe-InferredZpostgresql-typedA parsed SQL token.postgresql-typedRaw (non-markup) SQL stringpostgresql-typedA "$N" parameter placeholder (this is the only non-string-preserving token: "$012" becomes "$12")postgresql-typed"A "${expr}" expression placeholderpostgresql-typedA possibly-escaped question-mark: False for "?" or True for "\?"postgresql-typed1Parse a SQL string into a series of tokens. The  implementation for , inverts this sequence back to a SQL string.postgresql-typed Produces the original SQL string442015 Dylan Simon Safe-Inferred16m&postgresql-typed1Generic class of composite (row or record) types.postgresql-typedA  PGColumn t a4 instance describes how te decode a PostgreSQL type t to a.postgresql-typed7Decode the PostgreSQL text representation into a value.postgresql-typedDecode the PostgreSQL binary representation into a value. Only needs to be implemented if  is true.postgresql-typedA PGParameter t a4 instance describes how to encode a PostgreSQL type t from a.postgresql-typed3Encode a value to a PostgreSQL text representation.postgresql-typedEncode a value to a (quoted) literal value for use in SQL statements. Defaults to a quoted version of postgresql-typedEncode a value to a PostgreSQL representation. Defaults to the text representation by pgEncodepostgresql-typedA valid PostgreSQL type, its metadata, and corresponding Haskell representation. For conversion the other way (from Haskell type to PostgreSQL), see 7. Unfortunately any instances of this will be orphans.postgresql-typedThe default, native Haskell representation of this type, which should be as close as possible to the PostgreSQL representation.postgresql-typed5The string name of this type: specialized version of .postgresql-typed0Does this type support binary decoding? If so,  must be implemented for every  instance of this type.postgresql-typedA proxy type for PostgreSQL types. The type argument should be an (internal) name of a database type, as per format_type(OID) (usually the same as \dT+1). When the type's namespace (schema) is not in  search_path, this will be explicitly qualified, so you should be sure to have a consistent  search_path/ for all database connections. The underlying  should be considered a lifted .postgresql-typedA PostgreSQL literal identifier, generally corresponding to the "name" type (63-byte strings), but as it would be entered in a query, so may include double-quoting for special characters or schema-qualification.postgresql-typed0Raw bytes of the identifier (should really be a , but we need a working  instance for annotations).postgresql-typedParameters that affect how marshalling happens. Currenly we force all other relevant parameters at connect time. Nothing values represent unknown.postgresql-typedIf integer_datetimes is on$; only relevant for binary encoding.postgresql-typedThe server_version parameterpostgresql-typedA list of (nullable) data values, e.g. a single row or query parameters.postgresql-typed3A value passed to or from PostgreSQL in raw format.postgresql-typedThe standard text encoding format (also used for unknown formats)postgresql-typed9Special binary-encoded data. Not supported in all cases.postgresql-typed*The literal identifier as used in a query.postgresql-typed Reverses the  instantce.postgresql-typedFinal parameter encoding function used when a (nullable) parameter is passed to a prepared query.postgresql-typedFinal parameter escaping function used when a (nullable) parameter is passed to be substituted into a simple query.postgresql-typedFinal column decoding function used for a nullable result value.postgresql-typedFinal column decoding function used for a non-nullable result value.postgresql-typedProduce a SQL string literal by wrapping (and escaping) a string with single quotes.postgresql-typedShorthand for  . postgresql-typedDouble-quote a value (e.g., as an identifier). Does not properly handle unicode escaping (yet).postgresql-typedDouble-quote a value if it's "", "null", or contains any whitespace, '"', '\', or the characters given in the first argument.postgresql-typedParse double-quoted values ala .postgresql-typed Unquoted .postgresql-typedApplies utf-8 encoding.postgresql-typedHigh-precision representation of Rational as numeric. Unfortunately, numeric has an NaN, while Rational does not. NaN numeric values will produce exceptions.postgresql-typedRepresentation of DiffTime as interval. PostgreSQL stores months and days separately in intervals, but DiffTime does not. We collapse all interval fields into secondspostgresql-typed1The 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).--2015 Dylan Simon Safe-Inferred"1upostgresql-typedClass indicating that the first PostgreSQL type is a range of the second. This implies  and ' instances that will work for any type.postgresql-typedA end-point for a range, which may be nothing (infinity, NULL in PostgreSQL), open (inclusive), or closed (exclusive)postgresql-typedEquivalent to Bounded False Infinitypostgresql-typedTrue! if the range includes this boundpostgresql-typed$Unbounded endpoints are always open.postgresql-typedConstruct from parts: (makeBound (boundClosed b) (bound b) == bpostgresql-typedEmpty ranges treated as postgresql-typedEmpty ranges treated as postgresql-typedEquivalent to boundClosed . lowerBoundpostgresql-typedEquivalent to boundClosed . upperBoundpostgresql-typedCreate a point range [x,x]postgresql-typedExtract a point: getPoint (point x) == Just xpostgresql-typed6 for discrete (non-continuous) range types, using the  instancepostgresql-typedContains rangepostgresql-typedContains rangepostgresql-typedContains elementpostgresql-typed,Union ranges. Fails if ranges are disjoint.postgresql-typed%The constraint is only necessary for maxBound, unfortunatelypostgresql-typedTakes into account open vs. closed (but does not understand equivalent discrete bounds)postgresql-typed%The constraint is only necessary for minBound, unfortunatelypostgresql-typedTakes into account open vs. closed (but does not understand equivalent discrete bounds),,2015 Dylan Simon Safe-Inferred 1vpostgresql-typedConvert four bytes to network byte order, using unsafe casting.  would be better, but I couldn't find a good way to determine host byte order.2015 Dylan Simon Safe-Inferred1<|E postgresql-typedRepresents canonical/default PostgreSQL representation for various Haskell types, allowing convenient type-driven marshalling.postgresql-typed:The PostgreSOL type that this type should be converted to.postgresql-typedEncode a value using .postgresql-typedProduce a literal value for interpolation in a SQL statement using  . Using + is usually safer as it includes type cast.postgresql-typedDecode a value using .postgresql-typed.Produce a raw SQL literal from a value. Using 8 is usually safer when interpolating in a SQL statement.postgresql-typedProduce a safely type-cast literal value for interpolation in a SQL statement, e.g., "'123'::integer".postgresql-typed Identical to  .  but more efficient.postgresql-typedCreate an expression that literally substitutes each instance of ${expr} for the result of pgSafeLiteral expr, producing a lazy . This lets you do safe, type-driven literal substitution into SQL fragments without needing a full query, bypassing placeholder inference and any prepared queries, for example when using  or . Unlike most other TH functions, this does not require any database connection.   Safe-Inferred "(16postgresql-typedWait for ReadyForQuerypostgresql-typedProcess all pending messagespostgresql-typedRead from connection, returning immediate value or non-empty datapostgresql-typedExpected ReadyForQuery messagepostgresql-typedNotificationResponse messagepostgresql-typedErrorResponse messagepostgresql-typedAny other unhandled messagepostgresql-typed+PGException is thrown upon encountering an  with severity of ERROR, FATAL, or PANIC. It holds the message of the error.postgresql-typedPGBackendMessage represents a PostgreSQL protocol message that we'll receive. See  http://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.postgresql-typed.Each DataRow (result of a query) is a list of <, which are assumed to be text unless known to be otherwise.postgresql-typed(An ErrorResponse contains the severity, SQLSTATE#, and message of an error. See  http://www.postgresql.org/docs/current/interactive/protocol-error-fields.html.postgresql-typedA 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.postgresql-typedA 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.postgresql-typedPGFrontendMessage represents a PostgreSQL protocol message that we'll send. See  http://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.postgresql-typedDescribe a SQL query/statement. The SQL string can contain parameters ($1, $2, etc.).postgresql-typed*Parse SQL Destination (prepared statement)postgresql-typedSimpleQuery takes a simple SQL string. Parameters ($1, $2, etc.) aren't allowed.postgresql-typedSimple amortized fifopostgresql-typedAn established connection to the PostgreSQL server. These objects are not thread-safe and must only be used for a single request at a time.postgresql-typed>Information for how to connect to a database, to be passed to .postgresql-typed$The address to connect to the serverpostgresql-typedThe name of the databasepostgresql-typed3Extra parameters to set for the connection (e.g., (TimeZone, UTC))postgresql-typed!Log all low-level server messagespostgresql-typed)How to log server notice messages (e.g., print . PGError)postgresql-typedTLS modepostgresql-typedTLS is disabledpostgresql-typedEquivalent to sslmode=verify-full. Ie: Check the FQHN against the certicate's CNpostgresql-typedEquivalent to sslmode=verify-ca. Ie: Only check that the certificate has been signed by the root certificate we providepostgresql-typed Constructs a  to validate the server certificate with given root certificate (in PEM format)postgresql-typed8Produce a human-readable string representing the messagepostgresql-typedMessage SQLState code. See  http://www.postgresql.org/docs/current/static/errcodes-appendix.html.postgresql-typedA database connection with sane defaults: localhost:5432:postgrespostgresql-typed-The database information for this connection.postgresql-typed)The type environment for this connection.postgresql-typed>Given a message, determine the (optional) type ID and the bodypostgresql-typed)Send a message to PostgreSQL (low-level).postgresql-typedParse an incoming message.postgresql-typed5Receive the next message from PostgreSQL (low-level).postgresql-typedConnect to a PostgreSQL server.postgresql-typed.Disconnect cleanly from the PostgreSQL server.postgresql-typedDisconnect cleanly from the PostgreSQL server, but only if it's still connected.postgresql-typedPossibly 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.postgresql-typedDescribe 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).postgresql-typed;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).postgresql-typedA simple query which may contain multiple queries (separated by semi-colons) whose results are all ignored. This function can also be used for "SET" parameter queries if necessary, but it's safer better to use .postgresql-typedPrepare 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.postgresql-typedLike  but requests results lazily in chunks of the given size. Does not use a named portal, so other requests may not intervene.postgresql-typed1Close a previously prepared query (if necessary).postgresql-typedBegin a new transaction. If there is already a transaction in progress (created with  or ) instead creates a savepoint.postgresql-typedRollback to the most recent .postgresql-typedCommit the most recent .postgresql-typedRollback all active s.postgresql-typedCommit all active s.postgresql-typedWrap a computation in a ,  block, or  on exception.postgresql-typedPrepare, bind, execute, and close a single (unnamed) query, and return the number of rows affected, or Nothing if there are (ignored) result rows.postgresql-typed-Prepare a single query and return its handle.postgresql-typed"Close a previously prepared query.postgresql-typedBind a prepared statement, and return the row description. After , you must either call  until it completes (returns (_,  _)) or pgFinish before calling & again on the same prepared statement.postgresql-typedFetch some rows from an executed prepared statement, returning the next N result rows (if any) and number of affected rows when complete.postgresql-typed0Retrieve a notifications, blocking if necessary.postgresql-typed2Retrieve any pending notifications. Non-blocking.postgresql-typed$Return any message (throwing errors)postgresql-typedWait for NotificationResponsepostgresql-typed#Return any message or ReadyForQuery postgresql-typeda handle from postgresql-typeda handle from postgresql-typed SQL stringpostgresql-typedOptional type specificationspostgresql-typed1Guess nullability, otherwise assume everything ispostgresql-typeda list of parameter types, and a list of result field names, types, and nullability indicators.postgresql-typed SQL stringpostgresql-typed5The number of rows affected and a list of result rowspostgresql-typed SQL stringpostgresql-typedSQL statement with placeholderspostgresql-typed7Optional type specifications (only used for first call)postgresql-typed"Paremeters to bind to placeholderspostgresql-typed*Requested binary format for result columnspostgresql-typed*Chunk size (1 is common, 0 is all-at-once)postgresql-typed.Maximum number of rows to return, or 0 for allpostgresql-typedConnected socketpostgresql-typed"Maximum number of bytes to receivepostgresql-typed Data received Safe-Inferred"postgresql-typedA + along with cached information about types.postgresql-typedMap keyed on fromIntegral OID.postgresql-typed Create a .postgresql-typed6Flush the cached type list, forcing it to be reloaded.postgresql-typed%Get a map of types from the database.postgresql-typedGet a cached map of types.postgresql-typedLookup a type name by OID. This is an efficient, often pure operation.postgresql-typedLookup a type OID by type name. This is less common and thus less efficient than going the other way.2015 Dylan Simon Safe-Inferred1^ postgresql-typed 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 ()postgresql-typed/Run an action using the Template Haskell state.postgresql-typed?Run an action using the Template Haskell PostgreSQL connection.postgresql-typedSpecify 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.postgresql-typedForce reloading of all types from the database. This may be needed if you make structural changes to the database during compile-time.postgresql-typed/Lookup a type name by OID. Error if not found.postgresql-typedLookup a type OID by type name. This is less common and thus less efficient than going the other way. Fail if not found.postgresql-typedA type-aware wrapper to postgresql-typedTH expression to encode a  value to a  .postgresql-typedTH expression to decode a   to a ()  value.postgresql-typedTH expression calling . 2016 Dylan Simon Safe-Inferred"postgresql-typedData types that are based on database relations. Normally these instances are created using .postgresql-typed:Database name of table/relation (i.e., second argument to !). Normally this is the same as pgTypeID . 8, but this preserves any specified schema qualification.postgresql-typedDatabase names of columns.postgresql-typedCreate a new data type corresponding to the given PostgreSQL relation. For example, if you have 1CREATE TABLE foo (abc integer NOT NULL, def text), then %dataPGRelation "Foo" "foo" ("foo_"++) will be equivalent to: data Foo = Foo{ foo_abc :: PGVal "integer", foo_def :: Maybe (PGVal "text") } instance PGType "foo" where PGVal "foo" = Foo instance PGParameter "foo" Foo where ... instance PGColumn "foo" Foo where ... instance PGColumn "foo" (Maybe Foo) where ... -- to handle NULL in not null columns instance PGRep Foo where PGRepType = "foo" instance PGRecordType "foo" instance PGRelation Foo where pgColumnNames _ = ["abc", "def"] uncurryFoo :: (PGVal "integer", Maybe (PGVal "text")) -> Foo (Note that PGVal "integer" = Int32 and PGVal "text" = Text by default.) This provides instances for marshalling the corresponding composite/record types, e.g., using SELECT foo.*::foo FROM foo. If you want any derived instances, you'll need to create them yourself using StandaloneDeriving.Requires language extensions: TemplateHaskell, FlexibleInstances, MultiParamTypeClasses, DataKinds, TypeFamilies, PatternGuardspostgresql-typed&Haskell type and constructor to createpostgresql-typedPostgreSQL table/relation namepostgresql-typed4How to generate field names from column names, e.g.  ("table_"++) (input is )  Safe-Inferred )*1Spostgresql-typed9Flags affecting how and what type of query to build with .postgresql-typed&Create a query -- otherwise just call # to create a string (SQL fragment).postgresql-typedDisable nullability inference, treating all values as nullable (if  ) or not (if ).postgresql-typedPrepare and re-use query, binding parameters of the given types (inferring the rest, like PREPARE).postgresql-typedA prepared query that automatically is prepared in the database the first time it is run and bound with new parameters each subsequent time.postgresql-typedA simple one-shot query that simply substitutes literal representations of parameters for placeholders.postgresql-typedExecute a query and return the number of rows affected (or -1 if not known) and a list of results.postgresql-typedChange 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. If you want to add dynamic values to the query, it's best to use . For example: [pgSQL|SELECT a FROM t|] `unsafeModifyQuery` (<> (" WHERE a = " <> pgSafeLiteral x))postgresql-typedExecute a query that does not return results. Return the number of rows affected (or -1 if not known).postgresql-typed-Run a query and return a list of row results.postgresql-typedMake a simple query directly from a query string, with no type inferencepostgresql-typedMake a prepared query directly from a query string and bind parameters, with no type inferencepostgresql-typedRun 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.)postgresql-typed4Given 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 its best to understand SQL syntax, so placeholders are only interpreted in places postgres would understand them (i.e., not in quoted strings). Since this is not valid SQL otherwise, there is never reason to escape a literal ${. You can use $N placeholders in the query otherwise to refer to the N-th index placeholder expression.postgresql-typed4Given a SQL statement with placeholders of the form $N and a list of TH  ByteString expressions, return a new  ByteString expression that substitutes the expressions for the placeholders.postgresql-typed for a default (simple) query.postgresql-typed Construct a  from a SQL string. This is the underlying template function for  which you can use in largely the same way when you want to construct query strings from other variables. For example: selectQuery = "SELECT * FROM" selectFoo = $(makePGQuery simpleQueryFlags (selectQuery ++ " foo"))4The only caveat is that variables or functions like  selectQuery need to be defined in a different module (due to TH stage restrictions).postgresql-typedParse flags off the beginning of a query string, returning the flags and the remaining string.postgresql-typed!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  object that can be used to perform the SQL statement. If there are more $N placeholders than expressions, it will instead be a function accepting the additional parameters and returning a .Ideally, this mimics postgres' SQL parsing, so that placeholders and expressions will only be expanded when they are in valid positions (i.e., not inside quoted strings). Since ${ is not valid SQL otherwise, there should be no need to escape it.The statement may start with one of more special flags affecting the interpretation: ?To disable nullability inference, treating all result values as nullable, thus returning  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  where requested. This is makes unexpected NULL errors more likely.$ To create a 8 (using placeholder parameters) rather than the default  (using literal substitution). $(type,...)4To specify specific types for a prepared query (see  >http://www.postgresql.org/docs/current/static/sql-prepare.html for details), rather than inferring parameter types by default.#Only do literal ${} substitution using " and return a string, not a query. 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.If you want to construct queries out of string variables rather than quasi-quoted strings, you can use the lower-level  instead.postgresql-typed-Chunk size (1 is common, 0 is all-or-nothing)  Safe-Inferred0postgresql-typed5For backwards compatibility with old network package.postgresql-typed Convert a <-style string with placeholders into a new style SQL string.postgresql-typed queryTuples :: String -> (PGConnection -> IO [(column1, column2, ...)])Query a PostgreSQL server and return the results as a list of tuples.Example (where h is a handle from ): $(queryTuples "SELECT usesysid, usename FROM pg_user") h :: IO [(Maybe String, Maybe Integer)]postgresql-typed queryTuple :: 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 ): let sysid = 10::Integer; $(queryTuple "SELECT usesysid, usename FROM pg_user WHERE usesysid = {sysid}") h :: IO (Maybe (Maybe String, Maybe Integer))postgresql-typed ,execute :: String -> (PGConnection -> IO ())Convenience function to execute a statement on the PostgreSQL server.Example (where h is a handle from ):postgresql-typedRun 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  onException. I'm debating adding a  MonadPeelIO version.postgresql-typedRoll back a transaction.postgresql-typed9Ignore duplicate key errors. This is also limited to the  Monad.postgresql-typedthe host to connect topostgresql-typedthe port to connect onpostgresql-typedthe database to connect topostgresql-typedthe username to connect aspostgresql-typedthe password to connect withpostgresql-typed5a handle to communicate with the PostgreSQL server on   Safe-Inferredz 2015 Dylan Simon Safe-Inferred "1postgresql-typedA type based on a PostgreSQL enum. Automatically instantiated by .postgresql-typedThe database name of a value.postgresql-typed0Lookup a value matching the given database name.postgresql-typedList of all the values in the enum along with their database names.postgresql-typedCreate a new enum type corresponding to the given PostgreSQL enum type. For example, if you have &CREATE TYPE foo AS ENUM ('abc', 'DEF'), then !dataPGEnum "Foo" "foo" ("Foo_"++) will be equivalent to: data Foo = Foo_abc | Foo_DEF deriving (Eq, Ord, Enum, Bounded, Typeable) instance PGType "foo" where PGVal "foo" = Foo instance PGParameter "foo" Foo where ... instance PGColumn "foo" Foo where ... instance PGRep Foo where PGRepType = "foo" instance PGEnum Foo where pgEnumValues = [(Foo_abc, "abc"), (Foo_DEF, "DEF")]Requires language extensions: TemplateHaskell, FlexibleInstances, MultiParamTypeClasses, DeriveDataTypeable, DataKinds, TypeFamiliespostgresql-typedHaskell type to createpostgresql-typedPostgreSQL enum type namepostgresql-typed9How to generate constructor names from enum values, e.g.  ("Type_"++) (input is ) 2015 Dylan Simon Safe-Inferred"1]postgresql-typedClass indicating that the first PostgreSQL type is an array of the second. This implies  and  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.postgresql-typed0The character used as a delimeter. The default ,+ is correct for all standard types (except box).postgresql-typedThe 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.postgresql-typedAllow entirely non-null arrays as parameter inputs only. (Only supported on ghc >= 7.10 due to instance overlap.) Safe-Inferred՘2016 Dylan Simon Safe-Inferred "%&1=postgresql-typed A wrapped . This differs from a bare  in a few ways: 3It always has exactly one active transaction (with )"It automatically disconnects on GC*It provides a mutex around the underlying  for thread-safetypostgresql-typed)Number of rows to fetch (and cache) with  and each time  requires more rows. A higher value will result in fewer round-trips to the database but potentially more wasted data. Defaults to 1. 0 means fetch all rows.postgresql-typedUse the underlying  directly. You must be careful to ensure that the first invariant is preserved: you should not call , , or , on it. All other operations should be safe.postgresql-typedConvert an existing  to an HDBC-compatible . The caveats under 2 apply if you plan to continue using the original .postgresql-typed2Connect to a database for HDBC use (equivalent to  and ).postgresql-typedReload the table of all types from the database. This may be needed if you make structural changes to the database.postgresql-typed Change the  for new s created with /. Ideally this could be set with each call to  and 4, but the HDBC interface provides no way to do this. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                 /postgresql-typed-0.6.2.4-8L3MhHwd10o7lRNa63b6Xp"Database.PostgreSQL.Typed.ErrCodes"Database.PostgreSQL.Typed.SQLTokenDatabase.PostgreSQL.Typed.TypesDatabase.PostgreSQL.Typed.RangeDatabase.PostgreSQL.Typed.Inet!Database.PostgreSQL.Typed.Dynamic"Database.PostgreSQL.Typed.ProtocolDatabase.PostgreSQL.Typed.TH"Database.PostgreSQL.Typed.RelationDatabase.PostgreSQL.Typed.Query$Database.PostgreSQL.Typed.TemplatePGDatabase.PostgreSQL.Typed.EnumDatabase.PostgreSQL.Typed.ArrayDatabase.PostgreSQL.Typed.HDBCPGRep Data.Word byteSwap32 pgSimpleQuerypgSimpleQueries_#Database.PostgreSQL.Typed.TypeCacheL ByteStringDatabase.PostgreSQL.TypedPaths_postgresql_typedsuccessful_completionwarning$warning_dynamic_result_sets_returned!warning_implicit_zero_bit_padding-warning_null_value_eliminated_in_set_functionwarning_privilege_not_grantedwarning_privilege_not_revoked$warning_string_data_right_truncationwarning_deprecated_featureno_data*no_additional_dynamic_result_sets_returnedsql_statement_not_yet_completeconnection_exceptionconnection_does_not_existconnection_failure+sqlclient_unable_to_establish_sqlconnection1sqlserver_rejected_establishment_of_sqlconnectiontransaction_resolution_unknownprotocol_violationtriggered_action_exceptionfeature_not_supportedinvalid_transaction_initiationlocator_exceptioninvalid_locator_specificationinvalid_grantorinvalid_grant_operationinvalid_role_specificationdiagnostics_exception3stacked_diagnostics_accessed_without_active_handlercase_not_foundcardinality_violationdata_exception_ARRAY_ELEMENT_ERRORarray_subscript_errorcharacter_not_in_repertoiredatetime_field_overflow_DATETIME_VALUE_OUT_OF_RANGEdivision_by_zeroerror_in_assignmentescape_character_conflictindicator_overflowinterval_field_overflowinvalid_argument_for_logarithm#invalid_argument_for_ntile_function'invalid_argument_for_nth_value_function#invalid_argument_for_power_function*invalid_argument_for_width_bucket_function invalid_character_value_for_castinvalid_datetime_formatinvalid_escape_characterinvalid_escape_octetinvalid_escape_sequence#nonstandard_use_of_escape_character!invalid_indicator_parameter_valueinvalid_parameter_value#invalid_preceding_or_following_sizeinvalid_regular_expression!invalid_row_count_in_limit_clause)invalid_row_count_in_result_offset_clauseinvalid_tablesample_argumentinvalid_tablesample_repeat$invalid_time_zone_displacement_valueinvalid_use_of_escape_charactermost_specific_type_mismatchnull_value_not_allowed!null_value_no_indicator_parameternumeric_value_out_of_range!sequence_generator_limit_exceededstring_data_length_mismatchstring_data_right_truncationsubstring_error trim_errorunterminated_c_stringzero_length_character_stringfloating_point_exceptioninvalid_text_representationinvalid_binary_representationbad_copy_file_formatuntranslatable_characternot_an_xml_documentinvalid_xml_documentinvalid_xml_contentinvalid_xml_comment"invalid_xml_processing_instructionduplicate_json_object_key_valueinvalid_json_textinvalid_sql_json_subscriptmore_than_one_sql_json_itemno_sql_json_itemnon_numeric_sql_json_item non_unique_keys_in_a_json_object singleton_sql_json_item_requiredsql_json_array_not_foundsql_json_member_not_foundsql_json_number_not_foundsql_json_object_not_foundtoo_many_json_array_elementstoo_many_json_object_memberssql_json_scalar_requiredintegrity_constraint_violationrestrict_violationnot_null_violationforeign_key_violationunique_violationcheck_violationexclusion_violationinvalid_cursor_stateinvalid_transaction_stateactive_sql_transaction!branch_transaction_already_active)held_cursor_requires_same_isolation_level0inappropriate_access_mode_for_branch_transaction4inappropriate_isolation_level_for_branch_transaction0no_active_sql_transaction_for_branch_transactionread_only_sql_transaction.schema_and_data_statement_mixing_not_supportedno_active_sql_transactionin_failed_sql_transaction#idle_in_transaction_session_timeoutinvalid_sql_statement_nametriggered_data_change_violation#invalid_authorization_specificationinvalid_password+dependent_privilege_descriptors_still_existdependent_objects_still_existinvalid_transaction_terminationsql_routine_exception+s_r_e_function_executed_no_return_statement&s_r_e_modifying_sql_data_not_permitted(s_r_e_prohibited_sql_statement_attempted$s_r_e_reading_sql_data_not_permittedinvalid_cursor_nameexternal_routine_exception"e_r_e_containing_sql_not_permitted&e_r_e_modifying_sql_data_not_permitted(e_r_e_prohibited_sql_statement_attempted$e_r_e_reading_sql_data_not_permitted%external_routine_invocation_exception!e_r_i_e_invalid_sqlstate_returnede_r_i_e_null_value_not_allowed!e_r_i_e_trigger_protocol_violatede_r_i_e_srf_protocol_violated'e_r_i_e_event_trigger_protocol_violatedsavepoint_exceptioninvalid_savepoint_specificationinvalid_catalog_nameinvalid_schema_nametransaction_rollback*transaction_integrity_constraint_violationserialization_failurestatement_completion_unknowndeadlock_detected%syntax_error_or_access_rule_violation syntax_errorinsufficient_privilege cannot_coercegrouping_errorwindowing_errorinvalid_recursioninvalid_foreign_key invalid_name name_too_long reserved_namedatatype_mismatchindeterminate_datatypecollation_mismatchindeterminate_collationwrong_object_typegenerated_alwaysundefined_column_UNDEFINED_CURSOR_UNDEFINED_DATABASEundefined_function_UNDEFINED_PSTATEMENT_UNDEFINED_SCHEMAundefined_tableundefined_parameterundefined_objectduplicate_columnduplicate_cursorduplicate_databaseduplicate_functionduplicate_prepared_statementduplicate_schemaduplicate_tableduplicate_aliasduplicate_objectambiguous_columnambiguous_functionambiguous_parameterambiguous_aliasinvalid_column_referenceinvalid_column_definitioninvalid_cursor_definitioninvalid_database_definitioninvalid_function_definition%invalid_prepared_statement_definitioninvalid_schema_definitioninvalid_table_definitioninvalid_object_definitionwith_check_option_violationinsufficient_resources disk_full out_of_memorytoo_many_connectionsconfiguration_limit_exceededprogram_limit_exceededstatement_too_complextoo_many_columnstoo_many_arguments object_not_in_prerequisite_state object_in_usecant_change_runtime_paramlock_not_availableunsafe_new_enum_value_usageoperator_interventionquery_canceledadmin_shutdowncrash_shutdowncannot_connect_nowdatabase_dropped system_errorio_errorundefined_fileduplicate_filesnapshot_too_oldconfig_file_errorlock_file_exists fdw_errorfdw_column_name_not_found"fdw_dynamic_parameter_value_neededfdw_function_sequence_error'fdw_inconsistent_descriptor_informationfdw_invalid_attribute_valuefdw_invalid_column_namefdw_invalid_column_numberfdw_invalid_data_type!fdw_invalid_data_type_descriptors'fdw_invalid_descriptor_field_identifierfdw_invalid_handlefdw_invalid_option_indexfdw_invalid_option_name*fdw_invalid_string_length_or_buffer_lengthfdw_invalid_string_formatfdw_invalid_use_of_null_pointerfdw_too_many_handlesfdw_out_of_memoryfdw_no_schemasfdw_option_name_not_foundfdw_reply_handlefdw_schema_not_foundfdw_table_not_foundfdw_unable_to_create_executionfdw_unable_to_create_reply"fdw_unable_to_establish_connection plpgsql_errorraise_exception no_data_found too_many_rowsassert_failureinternal_errordata_corruptedindex_corruptednamesSQLTokenSQLParamSQLExprSQLQMark sqlTokens$fIsStringSQLToken$fShowSQLToken $fEqSQLToken PGRecordTypePGRecord PGStringTypeOIDPGColumnpgDecodepgDecodeBinary pgDecodeValue PGParameterpgEncode pgLiteral pgEncodeValuePGTypePGVal pgTypeNamepgBinaryColumnPGTypeID PGTypeProxyPGName pgNameBytes PGTypeEnvpgIntegerDatetimespgServerVersionPGValuesPGValue PGNullValue PGTextValue PGBinaryValue pgTextValue pgBinaryValueunknownPGTypeEnvpgNameBS pgNameStringpgEncodeParameterpgEscapeParameterpgDecodeColumnpgDecodeColumnNotNullpgQuote buildPGValuepgDQuote pgDQuoteFrom parsePGDQuote $fShowPGName$fIsStringPGName$fPGColumn"jsonb"Value$fPGParameter"jsonb"Value$fPGType"jsonb"$fPGColumn"json"Value$fPGParameter"json"Value$fPGType"json"$fPGColumn"uuid"UUID$fPGParameter"uuid"UUID$fPGType"uuid"$fPGColumn"numeric"Scientific $fPGParameter"numeric"Scientific$fPGColumn"numeric"Ratio$fPGParameter"numeric"Ratio$fPGType"numeric"$fPGColumn"interval"DiffTime$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 with time zone"(,)%$fPGParameter"time with time zone"(,)$fPGType"time with 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"$fPGType"bpchar"$fPGType"name"$fPGType"character varying"$fPGType"text"$fPGColumn"\"char\""Char$fPGParameter"\"char\""Char$fPGColumn"\"char\""Word8$fPGParameter"\"char\""Word8$fPGType"\"char\"""$fPGColumn"double precision"Double$$fPGParameter"double precision"Float%$fPGParameter"double precision"Double$fPGType"double precision"$fPGColumn"real"Double$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"boolean"Bool$fPGParameter"boolean"Bool$fPGType"boolean"$fPGColumn"void"()$fPGParameter"void"()$fPGType"void"$fPGParameter"any"PGValue$fPGColumntPGValue $fPGType"any"$fPGColumntMaybe$fPGParametertMaybe$fPGColumn"oid"Word32$fPGParameter"oid"Word32 $fPGType"oid"$fPGStringType"bpchar"$fPGStringType"name"!$fPGStringType"character varying"$fPGStringType"text"$fPGColumntText$fPGParametertText$fPGColumntText0$fPGParametertText0$fPGColumntByteString$fPGParametertByteString$fPGColumntPGName$fPGParametertPGName$fPGColumntByteString0$fPGParametertByteString0 $fPGColumnt[]$fPGParametert[]$fPGType"record"$fPGRecordType"record"$fPGColumntPGRecord$fPGParametertPGRecord $fEqPGName $fOrdPGName $fDataPGName$fShowPGTypeEnv $fShowPGValue $fEqPGValue PGRangeType PGSubTypepgRangeElementTypeRangeEmptylowerupper UpperBoundUpper boundUpper LowerBoundLower boundLowerBound UnboundedBounded _boundClosed_bound compareBoundsbound boundClosed makeBound lowerBound upperBound lowerClosed upperClosedemptyisEmptyfullisFullpointgetPointrangenormalbounded normalize normalize'@><@@>.overlaps intersectunion$fFunctorBound$fBoundedLowerBound$fOrdLowerBound$fBoundedUpperBound$fOrdUpperBound $fMonoidRange$fSemigroupRange $fShowRange$fFunctorRange$fPGRangeType"int8range"$fPGType"int8range"$fPGRangeType"daterange"$fPGType"daterange"$fPGRangeType"tstzrange"$fPGType"tstzrange"$fPGRangeType"tsrange"$fPGType"tsrange"$fPGRangeType"numrange"$fPGType"numrange"$fPGRangeType"int4range"$fPGType"int4range"$fPGColumntRange$fPGParametertRange $fEqRange $fOrdRange$fEqUpperBound$fFunctorUpperBound$fEqLowerBound$fFunctorLowerBound $fEqBoundPGInetPGInet6 pgInetAddr pgInetMask pgInetAddr6sockAddrPGInetbton32$fPGColumn"cidr"PGInet$fPGColumn"inet"PGInet$fPGParameter"cidr"PGInet$fPGParameter"inet"PGInet$fPGType"cidr"$fPGType"inet" $fReadPGInet $fShowPGInet $fEqPGInet PGRepTypepgTypeOf pgTypeOfProxy pgEncodeRep pgLiteralRep pgDecodeReppgLiteralString pgSafeLiteralpgSafeLiteralStringpgSubstituteLiterals $fPGRepValue $fPGRepUUID$fPGRepScientific $fPGRepRatio$fPGRepDiffTime$fPGRepUTCTime$fPGRepLocalTime $fPGRep(,)$fPGRepTimeOfDay $fPGRepDay $fPGRepText $fPGRepPGName$fPGRepByteString $fPGRep[] $fPGRepChar $fPGRepDouble $fPGRepFloat $fPGRepInt64 $fPGRepInt32 $fPGRepInt16 $fPGRepWord32 $fPGRepBool $fPGRep() $fPGRepMaybePGError pgErrorFieldsPGNotificationpgNotificationPidpgNotificationChannelpgNotificationPayloadPGRowDescriptionPGColDescription pgColName pgColTable pgColNumber pgColType pgColSize pgColModifier pgColBinary PGConnectionPGPreparedStatement PGDatabasepgDBAddrpgDBNamepgDBUserpgDBPass pgDBParams pgDBDebugpgDBLogMessagepgDBTLS PGTlsMode TlsDisabled TlsNoValidate TlsValidatePGTlsValidateModeTlsValidateFull TlsValidateCA pgTlsValidate pgSupportsTls pgErrorCodedefaultPGDatabasepgConnectionDatabase pgTypeEnv pgConnect pgDisconnectpgDisconnectOnce pgReconnect pgDescribepgPreparedQuerypgPreparedLazyQuerypgCloseStatementpgBegin pgRollbackpgCommit pgRollbackAll pgCommitAll pgTransactionpgRun pgPreparepgClosepgBindpgFetchpgGetNotificationpgGetNotifications$fEqPGDatabase$fExceptionPGError $fShowPGError$fRecvMsgPGBackendMessage$fRecvMsgPGNotification$fRecvMsgRecvNonBlock$fRecvMsgEither$fRecvMsgRecvSync$fShowRecvSync$fShowRecvNonBlock$fShowPGBackendMessage$fShowPGFrontendMessage$fShowPGNotification$fShowPGDatabase$fShowPGColDescription$fEqPGPreparedStatement$fShowPGPreparedStatement $fEqPGTlsMode$fShowPGTlsMode$fShowPGTlsValidateMode$fEqPGTlsValidateMode $fShowPGState $fEqPGState TPGValueInfo tpgValueNametpgValueTypeOID tpgValueTypetpgValueNullablegetTPGDatabasewithTPGTypeConnectionwithTPGConnectionuseTPGDatabasereloadTPGTypes tpgDescribetpgTypeEncodertpgTypeDecoder tpgTypeBinarydataPGRelation QueryFlags flagQuery flagNullable flagPreparePGPreparedQuery PGSimpleQueryPGQuery pgRunQueryunsafeModifyQuerygetQueryString pgExecutepgQueryrawPGSimpleQueryrawPGPreparedQuery pgLazyQuerysimpleQueryFlags makePGQueryparseQueryFlagspgSQL$fPGQueryByteString[]$fPGRawQuerySimpleQuery$fPGQuerySimpleQuery[]$fPGRawQueryPreparedQuery$fPGQueryPreparedQuery[]$fShowQueryParser$fFunctorQueryParser$fPGQueryQueryParsera$fIsStringQueryParser$fIsStringQueryParser0$fShowPreparedQuery$fShowSimpleQuery PGException queryTuples queryTupleexecutewithTransactionrollback insertIgnorePGEnum pgEnumName pgEnumValue pgEnumValues dataPGEnum PGArrayType PGElemTypepgArrayElementType pgArrayDelimPGArray$fPGType"int8range[]"$fPGType"daterange[]"$fPGType"tstzrange[]"$fPGType"tsrange[]"$fPGType"numrange[]"$fPGType"int4range[]"$fPGType"regdictionary[]"$fPGType"regconfig[]"$fPGType"gtsvector[]"$fPGType"tsquery[]"$fPGType"tsvector[]"$fPGType"txid_snapshot[]"$fPGType"uuid[]"$fPGType"cstring[]"$fPGType"record[]"$fPGType"regtype[]"$fPGType"regclass[]"$fPGType"regoperator[]"$fPGType"regoper[]"$fPGType"regprocedure[]"$fPGType"refcursor[]"$fPGType"numeric[]"$fPGType"varbit[]"$fPGType"bit[]"$fPGType"time with time zone[]"$fPGType"interval[]"$$fPGType"timestamp with time zone[]"'$fPGType"timestamp without time zone[]""$fPGType"time without time zone[]"$fPGType"date[]"$fPGType"character varying[]"$fPGType"bpchar[]"$fPGType"aclitem[]"$fPGType"inet[]"$fPGType"macaddr[]"$fPGType"money[]"$fPGType"circle[]"$fPGType"tinterval[]"$fPGType"reltime[]"$fPGType"abstime[]"$fPGType"double precision[]"$fPGType"real[]"$fPGType"cidr[]"$fPGType"line[]"$fPGType"polygon[]"$fPGType"box[]"$fPGType"path[]"$fPGType"lseg[]"$fPGType"point[]"$fPGType"xml[]"$fPGType"json[]"$fPGType"oidvector[]"$fPGType"cid[]"$fPGType"xid[]"$fPGType"tid[]"$fPGType"oid[]"$fPGType"text[]"$fPGType"regproc[]"$fPGType"integer[]"$fPGType"int2vector[]"$fPGType"smallint[]"$fPGType"bigint[]"$fPGType"name[]"$fPGType"\"char\"[]"$fPGType"bytea[]"$fPGType"boolean[]"$fPGArrayType"int8range[]"$fPGArrayType"daterange[]"$fPGArrayType"tstzrange[]"$fPGArrayType"tsrange[]"$fPGArrayType"numrange[]"$fPGArrayType"int4range[]"$fPGArrayType"regdictionary[]"$fPGArrayType"regconfig[]"$fPGArrayType"gtsvector[]"$fPGArrayType"tsquery[]"$fPGArrayType"tsvector[]"$fPGArrayType"txid_snapshot[]"$fPGArrayType"uuid[]"$fPGArrayType"cstring[]"$fPGArrayType"record[]"$fPGArrayType"regtype[]"$fPGArrayType"regclass[]"$fPGArrayType"regoperator[]"$fPGArrayType"regoper[]"$fPGArrayType"regprocedure[]"$fPGArrayType"refcursor[]"$fPGArrayType"numeric[]"$fPGArrayType"varbit[]"$fPGArrayType"bit[]"$$fPGArrayType"time with time zone[]"$fPGArrayType"interval[]")$fPGArrayType"timestamp with time zone[]",$fPGArrayType"timestamp without time zone[]"'$fPGArrayType"time without time zone[]"$fPGArrayType"date[]""$fPGArrayType"character varying[]"$fPGArrayType"bpchar[]"$fPGArrayType"aclitem[]"$fPGArrayType"inet[]"$fPGArrayType"macaddr[]"$fPGArrayType"money[]"$fPGArrayType"circle[]"$fPGArrayType"tinterval[]"$fPGArrayType"reltime[]"$fPGArrayType"abstime[]"!$fPGArrayType"double precision[]"$fPGArrayType"real[]"$fPGArrayType"cidr[]"$fPGArrayType"line[]"$fPGArrayType"polygon[]"$fPGArrayType"box[]"$fPGArrayType"path[]"$fPGArrayType"lseg[]"$fPGArrayType"point[]"$fPGArrayType"xml[]"$fPGArrayType"json[]"$fPGArrayType"oidvector[]"$fPGArrayType"cid[]"$fPGArrayType"xid[]"$fPGArrayType"tid[]"$fPGArrayType"oid[]"$fPGArrayType"text[]"$fPGArrayType"regproc[]"$fPGArrayType"integer[]"$fPGArrayType"int2vector[]"$fPGArrayType"smallint[]"$fPGArrayType"bigint[]"$fPGArrayType"name[]"$fPGArrayType"\"char\"[]"$fPGArrayType"bytea[]"$fPGArrayType"boolean[]"$fPGParametert[]0 ConnectionconnectionFetchSizewithPGConnectionfromPGConnectionconnect reloadTypes setFetchSize$fIConnectionConnectionbaseGHC.ShowshowList++:+: GHC.TypeLits symbolValghc-prim GHC.TypesSymbolbytestring-0.11.3.1Data.ByteString.Internal Data.DataData Data.StringIsStringData.ByteString.Lazy.InternaltoStrictData.ByteString.BuildertoLazyByteStringGHC.EnumEnumData.ByteString.Char8unpackRecvSync RecvNonBlock recvMsgData recvMsgSync recvMsgNotif recvMsgErrrecvMsg ErrorResponsePGBackendMessageDataRowParameterDescriptionRowDescriptionPGFrontendMessageDescribeStatementParse SimpleQueryQueuedisplayMessage messageBodypgSendgetMessageBodypgRecv GHC.MaybeJust recvNonBlockPGTypeConnectionPGTypesnewPGTypeConnectionflushPGTypeConnection pgGetTypes getPGTypes lookupPGType findPGType pgConnectiontpgType getTPGTypeOIDMaybe PGRelationpgRelationName pgColumnNamesTrueFalsesqlPlaceholders sqlSubstitutePortIDquerySQLNothingIOversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir#HDBC-2.4.0.4-FLbtzpAxmvN3gCjY2NLIbqDatabase.HDBC.StatementfetchRow connectionPG StatementDatabase.HDBC.Typesprepare