!.O      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F GHIJKLMNSafepostgresql-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 SimonSafe.postgresql-typedA parsed SQL token. postgresql-typedRaw (non-markup) SQL string postgresql-typedaA "$N" parameter placeholder (this is the only non-string-preserving token: "$012" becomes "$12") postgresql-typed"A "${expr}" expression placeholder postgresql-typed@A possibly-escaped question-mark: False for "?" or True for "\?" postgresql-typed1Parse a SQL string into a series of tokens. The O implementation for , inverts this sequence back to a SQL string.postgresql-typed Produces the original SQL string          P4Q42015 Dylan SimonNone.2=>?@AHVXs&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-typed[Decode 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-typedgEncode a value to a (quoted) literal value for use in SQL statements. Defaults to a quoted version of postgresql-typed_Encode 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 R.!postgresql-typed0Does this type support binary decoding? If so,  must be implemented for every  instance of this type."postgresql-typednA 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_pathP, this will be explicitly qualified, so you should be sure to have a consistent  search_path/ for all database connections. The underlying S 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 T, but we need a working U 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 parameter+postgresql-typedHA 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-typedAThe standard text encoding format (also used for unknown formats)/postgresql-typed9Special binary-encoded data. Not supported in all cases.3postgresql-typed*The literal identifier as used in a query.4postgresql-typed Reverses the V instantce.5postgresql-typedaFinal parameter encoding function used when a (nullable) parameter is passed to a prepared query.6postgresql-typedsFinal parameter escaping function used when a (nullable) parameter is passed to be substituted into a simple query.7postgresql-typed@Final column decoding function used for a nullable result value.8postgresql-typedDFinal column decoding function used for a non-nullable result value.9postgresql-typedTProduce a SQL string literal by wrapping (and escaping) a string with single quotes.:postgresql-typedShorthand for W . X;postgresql-typed`Double-quote a value (e.g., as an identifier). Does not properly handle unicode escaping (yet).<postgresql-typed}Double-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 4.?postgresql-typedApplies utf-8 encoding.Kpostgresql-typedHigh-precision representation of Rational as numeric. Unfortunately, numeric has an NaN, while Rational does not. NaN numeric values will produce exceptions.Npostgresql-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).- !"#$%&'()*+,./-0123456789:;<=-,./-01+"#'()*2$%&34 !56789;<=:2015 Dylan SimonNone.=>?@AHMV postgresql-typedXClass indicating that the first PostgreSQL type is a range of the second. This implies  and ' instances that will work for any type.postgresql-typeduA 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 Y 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-typedWTakes into account open vs. closed (but does not understand equivalent discrete bounds)postgresql-typed%The constraint is only necessary for minBound, unfortunatelypostgresql-typedWTakes into account open vs. closed (but does not understand equivalent discrete bounds),,2015 Dylan SimonNone .=?@ACHVpostgresql-typedAConvert four bytes to network byte order, using unsafe casting. N would be better, but I couldn't find a good way to determine host byte order.2015 Dylan SimonNone.8=>?@AHVX postgresql-typed~Represents 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-typedCProduce 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-typedVProduce a safely type-cast literal value for interpolation in a SQL statement, e.g., "'123' ::integer". postgresql-typed Identical to Z .   but more efficient. postgresql-typedACreate 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 Q. Unlike most other TH functions, this does not require any database connection.         None %.2=?PX/A\postgresql-typedWait for ReadyForQuery]postgresql-typedProcess all pending messages^postgresql-typedARead from connection, returning immediate value or non-empty data_postgresql-typedExpected ReadyForQuery message`postgresql-typedNotificationResponse messageapostgresql-typedErrorResponse messagebpostgresql-typedAny other unhandled message%postgresql-typed+PGException is thrown upon encountering an cN with severity of ERROR, FATAL, or PANIC. It holds the message of the error.dpostgresql-typedSPGBackendMessage represents a PostgreSQL protocol message that we'll receive. See  Phttp://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.epostgresql-typed.Each DataRow (result of a query) is a list of ,<, which are assumed to be text unless known to be otherwise.cpostgresql-typed(An ErrorResponse contains the severity, SQLSTATE#, and message of an error. See  Mhttp://www.postgresql.org/docs/current/interactive/protocol-error-fields.html.fpostgresql-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.gpostgresql-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.hpostgresql-typedQPGFrontendMessage represents a PostgreSQL protocol message that we'll send. See  Phttp://www.postgresql.org/docs/current/interactive/protocol-message-formats.html.ipostgresql-typedWDescribe a SQL query/statement. The SQL string can contain parameters ($1, $2, etc.).jpostgresql-typed*Parse SQL Destination (prepared statement)kpostgresql-typedRSimpleQuery takes a simple SQL string. Parameters ($1, $2, etc.) aren't allowed.lpostgresql-typedSimple amortized fifo7postgresql-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.9postgresql-typed>Information for how to connect to a database, to be passed to P.;postgresql-typed$The address to connect to the server<postgresql-typedThe name of the database?postgresql-typed3Extra parameters to set for the connection (e.g., (TimeZone, UTC))@postgresql-typed!Log all low-level server messagesApostgresql-typed)How to log server notice messages (e.g., print . PGError)Bpostgresql-typedTLS modeDpostgresql-typedTLS is disabledHpostgresql-typedQEquivalent to sslmode=verify-full. Ie: Check the FQHN against the certicate's CNIpostgresql-typedxEquivalent to sslmode=verify-ca. Ie: Only check that the certificate has been signed by the root certificate we provideJpostgresql-typed Constructs a CP to validate the server certificate with given root certificate (in PEM format)mpostgresql-typed8Produce a human-readable string representing the messageLpostgresql-typedMessage SQLState code. See  Dhttp://www.postgresql.org/docs/current/static/errcodes-appendix.html.Mpostgresql-typedBA database connection with sane defaults: localhost:5432:postgresNpostgresql-typed-The database information for this connection.Opostgresql-typed)The type environment for this connection.npostgresql-typed>Given a message, determine the (optional) type ID and the bodyopostgresql-typed)Send a message to PostgreSQL (low-level).ppostgresql-typedParse an incoming message.qpostgresql-typed5Receive the next message from PostgreSQL (low-level).Ppostgresql-typedConnect to a PostgreSQL server.Qpostgresql-typed.Disconnect cleanly from the PostgreSQL server.Rpostgresql-typedPDisconnect cleanly from the PostgreSQL server, but only if it's still connected.Spostgresql-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.Tpostgresql-typed 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).Upostgresql-typed;A simple query is one which requires sending only a single k 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).Vpostgresql-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 ?.Wpostgresql-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.Xpostgresql-typedLike W| but requests results lazily in chunks of the given size. Does not use a named portal, so other requests may not intervene.Ypostgresql-typed1Close a previously prepared query (if necessary).Zpostgresql-typedUBegin a new transaction. If there is already a transaction in progress (created with Z or _) instead creates a savepoint.[postgresql-typedRollback to the most recent Z.\postgresql-typedCommit the most recent Z.]postgresql-typedRollback all active Zs.^postgresql-typedCommit all active Zs._postgresql-typedWrap a computation in a Z, \ 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.apostgresql-typed-Prepare a single query and return its handle.bpostgresql-typed"Close a previously prepared query.cpostgresql-typedBBind a prepared statement, and return the row description. After c, you must either call d until it completes (returns (_, r _)) or pgFinish before calling c& again on the same prepared statement.dpostgresql-typedFetch some rows from an executed prepared statement, returning the next N result rows (if any) and number of affected rows when complete.epostgresql-typed0Retrieve a notifications, blocking if necessary.fpostgresql-typed2Retrieve any pending notifications. Non-blocking.jpostgresql-typed$Return any message (throwing errors)kpostgresql-typedWait for NotificationResponsempostgresql-typed#Return any message or ReadyForQuery Qpostgresql-typeda handle from PRpostgresql-typeda handle from PTpostgresql-typed SQL stringpostgresql-typedOptional type specificationspostgresql-typed1Guess nullability, otherwise assume everything ispostgresql-typed_a list of parameter types, and a list of result field names, types, and nullability indicators.Upostgresql-typed SQL stringpostgresql-typed5The number of rows affected and a list of result rowsVpostgresql-typed SQL stringWpostgresql-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 columnsXpostgresql-typed*Chunk size (1 is common, 0 is all-at-once)dpostgresql-typed.Maximum number of rows to return, or 0 for allspostgresql-typedConnected socketpostgresql-typed"Maximum number of bytes to receivepostgresql-typed Data receivedB%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefB9:;<=>?@ABM7%&'CDEFGHILNOPQSTUVWXYZ\[^]_R`8ab./0123456-cd()*+,efJKNone$tpostgresql-typedA 7+ along with cached information about types.upostgresql-typedMap keyed on fromIntegral OID.vpostgresql-typed Create a t.wpostgresql-typed6Flush the cached type list, forcing it to be reloaded.xpostgresql-typed%Get a map of types from the database.ypostgresql-typedGet a cached map of types.zpostgresql-typedGLookup a type name by OID. This is an efficient, often pure operation.{postgresql-typedfLookup a type OID by type name. This is less common and thus less efficient than going the other way.t|uvwxz{2015 Dylan SimonNone.>X8 postgresql-typed Generate a 9& 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 S: 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-typedzLookup 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 Tpostgresql-typedTH expression to encode a  value to a  .postgresql-typedTH expression to decode a   to a ()  value.postgresql-typedTH expression calling !.~~ 2016 Dylan SimonNone>PTpostgresql-typed]Data 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-typedaCreate 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" = Textm by default.) This provides instances for marshalling the corresponding composite/record types, e.g., using SELECT foo.*::foo FROM fooc. 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 4) None &'.=>?@ACpostgresql-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-typedCDisable nullability inference, treating all values as nullable (if  ) or not (if ).postgresql-typedcPrepare 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-typedgA simple one-shot query that simply substitutes literal representations of parameters for placeholders.postgresql-typedbExecute 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: T[pgSQL|SELECT a FROM t|] `unsafeModifyQuery` (<> (" WHERE a = " <> pgSafeLiteral x))postgresql-typedgExecute 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-typedHMake a simple query directly from a query string, with no type inferencepostgresql-typed^Make 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 $NW 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  ByteStringB expression that substitutes the expressions for the placeholders.postgresql-typed for a default (simple) query.postgresql-typed Construct a B from a SQL string. This is the underlying template function for w which you can use in largely the same way when you want to construct query strings from other variables. For example: aselectQuery = "SELECT * FROM" selectFoo = $(makePGQuery simpleQueryFlags (selectQuery ++ " foo"))4The only caveat is that variables or functions like  selectQueryI need to be defined in a different module (due to TH stage restrictions).postgresql-typed^Parse 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 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 .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 ${B is not valid SQL otherwise, there should be no need to escape it.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 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.wIf 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) Nonepostgresql-typed5For backwards compatibility with old network package.postgresql-typed Convert a <-style string with placeholders into a new style SQL string.postgresql-typed 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 ): ^$(queryTuples "SELECT usesysid, usename FROM pg_user") h :: IO [(Maybe String, Maybe Integer)]postgresql-typed 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 ): 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 ())EConvenience 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 Q QNonem%&'79:;<=>?@ABMPQ_%&'9:;<=>?@ABM7PQ_ 2015 Dylan SimonNone .=?@Apostgresql-typedAA 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-typedCList of all the values in the enum along with their database names.postgresql-typedbCreate 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 4) 2015 Dylan SimonNone.=>?@AHVpostgresql-typedYClass 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.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.Epostgresql-typedrAllow entirely non-null arrays as parameter inputs only. (Only supported on ghc >= 7.10 due to instance overlap.)Safe2016 Dylan SimonNone "#.=?@A[Gpostgresql-typed A wrapped 7. This differs from a bare 7 in a few ways: 3It always has exactly one active transaction (with Z)"It automatically disconnects on GC*It provides a mutex around the underlying 7 for thread-safetyHpostgresql-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.Ipostgresql-typedUse the underlying 7d directly. You must be careful to ensure that the first invariant is preserved: you should not call Z, \, or [, on it. All other operations should be safe.Jpostgresql-typedConvert an existing 7 to an HDBC-compatible G. The caveats under 2 apply if you plan to continue using the original 7.Kpostgresql-typed2Connect to a database for HDBC use (equivalent to P and Z).Lpostgresql-typedtReload the table of all types from the database. This may be needed if you make structural changes to the database.Mpostgresql-typed Change the H 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.GHIJKLMGKJILHM !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !!"#$%&'()**+,-./0123456789:;;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345677899:;<=>>?@ABCDEFGHHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                         ^                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L   MNOPQRSTUVWXYZV[\]^_`aVbcVde`fg`hiVjk`lm`nopqrstuvwxyz{|}~VV   ]^]^    V]^/postgresql-typed-0.6.1.2-JssrHBNxfd7FlBRKRWfYia"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 $fShowPGValue $fEqPGValue$fShowPGTypeEnv $fEqPGName $fOrdPGName $fDataPGName 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 $fEqBound$fEqLowerBound$fFunctorLowerBound$fEqUpperBound$fFunctorUpperBound $fEqRange $fOrdRangePGInetPGInet6 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 $fShowPGState $fEqPGState$fShowPGTlsValidateMode$fEqPGTlsValidateMode $fEqPGTlsMode$fShowPGTlsMode$fEqPGPreparedStatement$fShowPGPreparedStatement$fShowPGColDescription$fShowPGDatabase$fShowPGNotification$fShowPGFrontendMessage$fShowPGBackendMessage$fShowRecvNonBlock$fShowRecvSync TPGValueInfo tpgValueNametpgValueTypeOID tpgValueTypetpgValueNullablegetTPGDatabasewithTPGTypeConnectionwithTPGConnectionuseTPGDatabasereloadTPGTypes tpgDescribetpgTypeEncodertpgTypeDecoder tpgTypeBinarydataPGRelation QueryFlags flagQuery flagNullable flagPreparePGPreparedQuery PGSimpleQueryPGQuery pgRunQueryunsafeModifyQuerygetQueryString pgExecutepgQueryrawPGSimpleQueryrawPGPreparedQuery pgLazyQuerysimpleQueryFlags makePGQueryparseQueryFlagspgSQL$fPGQueryByteString[]$fPGRawQuerySimpleQuery$fPGQuerySimpleQuery[]$fPGRawQueryPreparedQuery$fPGQueryPreparedQuery[]$fShowQueryParser$fFunctorQueryParser$fPGQueryQueryParsera$fIsStringQueryParser$fIsStringQueryParser0$fShowSimpleQuery$fShowPreparedQuery 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.10.8.2Data.ByteString.Internal Data.DataData Data.StringIsStringData.ByteString.LazytoStrictData.ByteString.BuildertoLazyByteStringGHC.EnumEnumData.ByteString.Char8unpackData.ByteString.Lazy.InternalRecvSync RecvNonBlock recvMsgData recvMsgSync recvMsgNotif recvMsgErrrecvMsg ErrorResponsePGBackendMessageDataRowParameterDescriptionRowDescriptionPGFrontendMessageDescribeStatementParse SimpleQueryQueuedisplayMessage messageBodypgSendgetMessageBodypgRecv GHC.MaybeJust recvNonBlockPGTypeConnectionPGTypesnewPGTypeConnectionflushPGTypeConnection pgGetTypes getPGTypes lookupPGType findPGType pgConnectiontpgType getTPGTypeOIDMaybe PGRelationpgRelationName pgColumnNamesTrueFalsesqlPlaceholders sqlSubstitutePortIDquerySQLNothingIOversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName#HDBC-2.4.0.3-8VtqEjvedyhIee6tzFusJ9Database.HDBC.StatementfetchRow connectionPG StatementDatabase.HDBC.Typesprepare