From 316c6dc3dca7cdcbe7cd1338f38b1116b35a4e77 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 26 Dec 2020 14:09:58 -0500 Subject: [PATCH] Update codegen sources to 13.1 --- codegen/src/errcodes.txt | 3 +- codegen/src/pg_range.dat | 2 +- codegen/src/pg_type.dat | 53 ++- postgres-types/src/type_gen.rs | 90 +++- tokio-postgres/src/error/sqlstate.rs | 605 ++++++++++++++------------- 5 files changed, 433 insertions(+), 320 deletions(-) diff --git a/codegen/src/errcodes.txt b/codegen/src/errcodes.txt index 867e98b6..c79312ed 100644 --- a/codegen/src/errcodes.txt +++ b/codegen/src/errcodes.txt @@ -2,7 +2,7 @@ # errcodes.txt # PostgreSQL error codes # -# Copyright (c) 2003-2019, PostgreSQL Global Development Group +# Copyright (c) 2003-2020, PostgreSQL Global Development Group # # This list serves as the basis for generating source files containing error # codes. It is kept in a common format to make sure all these source files have @@ -207,6 +207,7 @@ Section: Class 22 - Data Exception 2200S E ERRCODE_INVALID_XML_COMMENT invalid_xml_comment 2200T E ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION invalid_xml_processing_instruction 22030 E ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE duplicate_json_object_key_value +22031 E ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION invalid_argument_for_sql_json_datetime_function 22032 E ERRCODE_INVALID_JSON_TEXT invalid_json_text 22033 E ERRCODE_INVALID_SQL_JSON_SUBSCRIPT invalid_sql_json_subscript 22034 E ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM more_than_one_sql_json_item diff --git a/codegen/src/pg_range.dat b/codegen/src/pg_range.dat index dd9baa26..479754c2 100644 --- a/codegen/src/pg_range.dat +++ b/codegen/src/pg_range.dat @@ -3,7 +3,7 @@ # pg_range.dat # Initial contents of the pg_range system catalog. # -# Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group # Portions Copyright (c) 1994, Regents of the University of California # # src/include/catalog/pg_range.dat diff --git a/codegen/src/pg_type.dat b/codegen/src/pg_type.dat index be49e001..e8be0008 100644 --- a/codegen/src/pg_type.dat +++ b/codegen/src/pg_type.dat @@ -3,7 +3,7 @@ # pg_type.dat # Initial contents of the pg_type system catalog. # -# Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group # Portions Copyright (c) 1994, Regents of the University of California # # src/include/catalog/pg_type.dat @@ -177,6 +177,10 @@ typtype => 'p', typcategory => 'P', typinput => 'pg_ddl_command_in', typoutput => 'pg_ddl_command_out', typreceive => 'pg_ddl_command_recv', typsend => 'pg_ddl_command_send', typalign => 'ALIGNOF_POINTER' }, +{ oid => '5069', array_type_oid => '271', descr => 'full transaction id', + typname => 'xid8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', + typcategory => 'U', typinput => 'xid8in', typoutput => 'xid8out', + typreceive => 'xid8recv', typsend => 'xid8send', typalign => 'd' }, # OIDS 600 - 699 @@ -215,9 +219,9 @@ { oid => '700', array_type_oid => '1021', descr => 'single-precision floating point number, 4-byte storage', - typname => 'float4', typlen => '4', typbyval => 'FLOAT4PASSBYVAL', - typcategory => 'N', typinput => 'float4in', typoutput => 'float4out', - typreceive => 'float4recv', typsend => 'float4send', typalign => 'i' }, + typname => 'float4', typlen => '4', typbyval => 't', typcategory => 'N', + typinput => 'float4in', typoutput => 'float4out', typreceive => 'float4recv', + typsend => 'float4send', typalign => 'i' }, { oid => '701', array_type_oid => '1022', descr => 'double-precision floating point number, 8-byte storage', typname => 'float8', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', @@ -379,6 +383,11 @@ typname => 'regclass', typlen => '4', typbyval => 't', typcategory => 'N', typinput => 'regclassin', typoutput => 'regclassout', typreceive => 'regclassrecv', typsend => 'regclasssend', typalign => 'i' }, +{ oid => '4191', array_type_oid => '4192', descr => 'registered collation', + typname => 'regcollation', typlen => '4', typbyval => 't', typcategory => 'N', + typinput => 'regcollationin', typoutput => 'regcollationout', + typreceive => 'regcollationrecv', typsend => 'regcollationsend', + typalign => 'i' }, { oid => '2206', array_type_oid => '2211', descr => 'registered type', typname => 'regtype', typlen => '4', typbyval => 't', typcategory => 'N', typinput => 'regtypein', typoutput => 'regtypeout', @@ -451,6 +460,11 @@ typcategory => 'U', typinput => 'txid_snapshot_in', typoutput => 'txid_snapshot_out', typreceive => 'txid_snapshot_recv', typsend => 'txid_snapshot_send', typalign => 'd', typstorage => 'x' }, +{ oid => '5038', array_type_oid => '5039', descr => 'snapshot', + typname => 'pg_snapshot', typlen => '-1', typbyval => 'f', typcategory => 'U', + typinput => 'pg_snapshot_in', typoutput => 'pg_snapshot_out', + typreceive => 'pg_snapshot_recv', typsend => 'pg_snapshot_send', + typalign => 'd', typstorage => 'x' }, # range types { oid => '3904', array_type_oid => '3905', descr => 'range of integers', @@ -546,10 +560,6 @@ typtype => 'p', typcategory => 'P', typinput => 'internal_in', typoutput => 'internal_out', typreceive => '-', typsend => '-', typalign => 'ALIGNOF_POINTER' }, -{ oid => '2282', descr => 'obsolete, deprecated pseudo-type', - typname => 'opaque', typlen => '4', typbyval => 't', typtype => 'p', - typcategory => 'P', typinput => 'opaque_in', typoutput => 'opaque_out', - typreceive => '-', typsend => '-', typalign => 'i' }, { oid => '2283', descr => 'pseudo-type representing a polymorphic base type', typname => 'anyelement', typlen => '4', typbyval => 't', typtype => 'p', typcategory => 'P', typinput => 'anyelement_in', @@ -590,9 +600,34 @@ typoutput => 'table_am_handler_out', typreceive => '-', typsend => '-', typalign => 'i' }, { oid => '3831', - descr => 'pseudo-type representing a polymorphic base type that is a range', + descr => 'pseudo-type representing a range over a polymorphic base type', typname => 'anyrange', typlen => '-1', typbyval => 'f', typtype => 'p', typcategory => 'P', typinput => 'anyrange_in', typoutput => 'anyrange_out', typreceive => '-', typsend => '-', typalign => 'd', typstorage => 'x' }, +{ oid => '5077', + descr => 'pseudo-type representing a polymorphic common type', + typname => 'anycompatible', typlen => '4', typbyval => 't', typtype => 'p', + typcategory => 'P', typinput => 'anycompatible_in', + typoutput => 'anycompatible_out', typreceive => '-', typsend => '-', + typalign => 'i' }, +{ oid => '5078', + descr => 'pseudo-type representing an array of polymorphic common type elements', + typname => 'anycompatiblearray', typlen => '-1', typbyval => 'f', + typtype => 'p', typcategory => 'P', typinput => 'anycompatiblearray_in', + typoutput => 'anycompatiblearray_out', + typreceive => 'anycompatiblearray_recv', typsend => 'anycompatiblearray_send', + typalign => 'd', typstorage => 'x' }, +{ oid => '5079', + descr => 'pseudo-type representing a polymorphic common type that is not an array', + typname => 'anycompatiblenonarray', typlen => '4', typbyval => 't', + typtype => 'p', typcategory => 'P', typinput => 'anycompatiblenonarray_in', + typoutput => 'anycompatiblenonarray_out', typreceive => '-', typsend => '-', + typalign => 'i' }, +{ oid => '5080', + descr => 'pseudo-type representing a range over a polymorphic common type', + typname => 'anycompatiblerange', typlen => '-1', typbyval => 'f', + typtype => 'p', typcategory => 'P', typinput => 'anycompatiblerange_in', + typoutput => 'anycompatiblerange_out', typreceive => '-', typsend => '-', + typalign => 'd', typstorage => 'x' }, ] diff --git a/postgres-types/src/type_gen.rs b/postgres-types/src/type_gen.rs index 8156ccfa..85978096 100644 --- a/postgres-types/src/type_gen.rs +++ b/postgres-types/src/type_gen.rs @@ -35,6 +35,7 @@ pub enum Inner { PgNodeTree, JsonArray, TableAmHandler, + Xid8Array, IndexAmHandler, Point, Lseg, @@ -125,7 +126,6 @@ pub enum Inner { Trigger, LanguageHandler, Internal, - Opaque, Anyelement, RecordArray, Anynonarray, @@ -172,7 +172,16 @@ pub enum Inner { RegnamespaceArray, Regrole, RegroleArray, + Regcollation, + RegcollationArray, PgMcvList, + PgSnapshot, + PgSnapshotArray, + Xid8, + Anycompatible, + Anycompatiblearray, + Anycompatiblenonarray, + AnycompatibleRange, Other(Arc), } @@ -201,6 +210,7 @@ impl Inner { 194 => Some(Inner::PgNodeTree), 199 => Some(Inner::JsonArray), 269 => Some(Inner::TableAmHandler), + 271 => Some(Inner::Xid8Array), 325 => Some(Inner::IndexAmHandler), 600 => Some(Inner::Point), 601 => Some(Inner::Lseg), @@ -291,7 +301,6 @@ impl Inner { 2279 => Some(Inner::Trigger), 2280 => Some(Inner::LanguageHandler), 2281 => Some(Inner::Internal), - 2282 => Some(Inner::Opaque), 2283 => Some(Inner::Anyelement), 2287 => Some(Inner::RecordArray), 2776 => Some(Inner::Anynonarray), @@ -338,7 +347,16 @@ impl Inner { 4090 => Some(Inner::RegnamespaceArray), 4096 => Some(Inner::Regrole), 4097 => Some(Inner::RegroleArray), + 4191 => Some(Inner::Regcollation), + 4192 => Some(Inner::RegcollationArray), 5017 => Some(Inner::PgMcvList), + 5038 => Some(Inner::PgSnapshot), + 5039 => Some(Inner::PgSnapshotArray), + 5069 => Some(Inner::Xid8), + 5077 => Some(Inner::Anycompatible), + 5078 => Some(Inner::Anycompatiblearray), + 5079 => Some(Inner::Anycompatiblenonarray), + 5080 => Some(Inner::AnycompatibleRange), _ => None, } } @@ -367,6 +385,7 @@ impl Inner { Inner::PgNodeTree => 194, Inner::JsonArray => 199, Inner::TableAmHandler => 269, + Inner::Xid8Array => 271, Inner::IndexAmHandler => 325, Inner::Point => 600, Inner::Lseg => 601, @@ -457,7 +476,6 @@ impl Inner { Inner::Trigger => 2279, Inner::LanguageHandler => 2280, Inner::Internal => 2281, - Inner::Opaque => 2282, Inner::Anyelement => 2283, Inner::RecordArray => 2287, Inner::Anynonarray => 2776, @@ -504,7 +522,16 @@ impl Inner { Inner::RegnamespaceArray => 4090, Inner::Regrole => 4096, Inner::RegroleArray => 4097, + Inner::Regcollation => 4191, + Inner::RegcollationArray => 4192, Inner::PgMcvList => 5017, + Inner::PgSnapshot => 5038, + Inner::PgSnapshotArray => 5039, + Inner::Xid8 => 5069, + Inner::Anycompatible => 5077, + Inner::Anycompatiblearray => 5078, + Inner::Anycompatiblenonarray => 5079, + Inner::AnycompatibleRange => 5080, Inner::Other(ref u) => u.oid, } } @@ -533,6 +560,7 @@ impl Inner { Inner::PgNodeTree => &Kind::Simple, Inner::JsonArray => &Kind::Array(Type(Inner::Json)), Inner::TableAmHandler => &Kind::Pseudo, + Inner::Xid8Array => &Kind::Array(Type(Inner::Xid8)), Inner::IndexAmHandler => &Kind::Pseudo, Inner::Point => &Kind::Simple, Inner::Lseg => &Kind::Simple, @@ -623,7 +651,6 @@ impl Inner { Inner::Trigger => &Kind::Pseudo, Inner::LanguageHandler => &Kind::Pseudo, Inner::Internal => &Kind::Pseudo, - Inner::Opaque => &Kind::Pseudo, Inner::Anyelement => &Kind::Pseudo, Inner::RecordArray => &Kind::Pseudo, Inner::Anynonarray => &Kind::Pseudo, @@ -670,7 +697,16 @@ impl Inner { Inner::RegnamespaceArray => &Kind::Array(Type(Inner::Regnamespace)), Inner::Regrole => &Kind::Simple, Inner::RegroleArray => &Kind::Array(Type(Inner::Regrole)), + Inner::Regcollation => &Kind::Simple, + Inner::RegcollationArray => &Kind::Array(Type(Inner::Regcollation)), Inner::PgMcvList => &Kind::Simple, + Inner::PgSnapshot => &Kind::Simple, + Inner::PgSnapshotArray => &Kind::Array(Type(Inner::PgSnapshot)), + Inner::Xid8 => &Kind::Simple, + Inner::Anycompatible => &Kind::Pseudo, + Inner::Anycompatiblearray => &Kind::Pseudo, + Inner::Anycompatiblenonarray => &Kind::Pseudo, + Inner::AnycompatibleRange => &Kind::Pseudo, Inner::Other(ref u) => &u.kind, } } @@ -699,6 +735,7 @@ impl Inner { Inner::PgNodeTree => "pg_node_tree", Inner::JsonArray => "_json", Inner::TableAmHandler => "table_am_handler", + Inner::Xid8Array => "_xid8", Inner::IndexAmHandler => "index_am_handler", Inner::Point => "point", Inner::Lseg => "lseg", @@ -789,7 +826,6 @@ impl Inner { Inner::Trigger => "trigger", Inner::LanguageHandler => "language_handler", Inner::Internal => "internal", - Inner::Opaque => "opaque", Inner::Anyelement => "anyelement", Inner::RecordArray => "_record", Inner::Anynonarray => "anynonarray", @@ -836,7 +872,16 @@ impl Inner { Inner::RegnamespaceArray => "_regnamespace", Inner::Regrole => "regrole", Inner::RegroleArray => "_regrole", + Inner::Regcollation => "regcollation", + Inner::RegcollationArray => "_regcollation", Inner::PgMcvList => "pg_mcv_list", + Inner::PgSnapshot => "pg_snapshot", + Inner::PgSnapshotArray => "_pg_snapshot", + Inner::Xid8 => "xid8", + Inner::Anycompatible => "anycompatible", + Inner::Anycompatiblearray => "anycompatiblearray", + Inner::Anycompatiblenonarray => "anycompatiblenonarray", + Inner::AnycompatibleRange => "anycompatiblerange", Inner::Other(ref u) => &u.name, } } @@ -908,6 +953,9 @@ impl Type { /// TABLE_AM_HANDLER pub const TABLE_AM_HANDLER: Type = Type(Inner::TableAmHandler); + /// XID8[] + pub const XID8_ARRAY: Type = Type(Inner::Xid8Array); + /// INDEX_AM_HANDLER - pseudo-type for the result of an index AM handler function pub const INDEX_AM_HANDLER: Type = Type(Inner::IndexAmHandler); @@ -1178,9 +1226,6 @@ impl Type { /// INTERNAL - pseudo-type representing an internal data structure pub const INTERNAL: Type = Type(Inner::Internal); - /// OPAQUE - obsolete, deprecated pseudo-type - pub const OPAQUE: Type = Type(Inner::Opaque); - /// ANYELEMENT - pseudo-type representing a polymorphic base type pub const ANYELEMENT: Type = Type(Inner::Anyelement); @@ -1259,7 +1304,7 @@ impl Type { /// JSONB[] pub const JSONB_ARRAY: Type = Type(Inner::JsonbArray); - /// ANYRANGE - pseudo-type representing a polymorphic base type that is a range + /// ANYRANGE - pseudo-type representing a range over a polymorphic base type pub const ANY_RANGE: Type = Type(Inner::AnyRange); /// EVENT_TRIGGER - pseudo-type for the result of an event trigger function @@ -1319,6 +1364,33 @@ impl Type { /// REGROLE[] pub const REGROLE_ARRAY: Type = Type(Inner::RegroleArray); + /// REGCOLLATION - registered collation + pub const REGCOLLATION: Type = Type(Inner::Regcollation); + + /// REGCOLLATION[] + pub const REGCOLLATION_ARRAY: Type = Type(Inner::RegcollationArray); + /// PG_MCV_LIST - multivariate MCV list pub const PG_MCV_LIST: Type = Type(Inner::PgMcvList); + + /// PG_SNAPSHOT - snapshot + pub const PG_SNAPSHOT: Type = Type(Inner::PgSnapshot); + + /// PG_SNAPSHOT[] + pub const PG_SNAPSHOT_ARRAY: Type = Type(Inner::PgSnapshotArray); + + /// XID8 - full transaction id + pub const XID8: Type = Type(Inner::Xid8); + + /// ANYCOMPATIBLE - pseudo-type representing a polymorphic common type + pub const ANYCOMPATIBLE: Type = Type(Inner::Anycompatible); + + /// ANYCOMPATIBLEARRAY - pseudo-type representing an array of polymorphic common type elements + pub const ANYCOMPATIBLEARRAY: Type = Type(Inner::Anycompatiblearray); + + /// ANYCOMPATIBLENONARRAY - pseudo-type representing a polymorphic common type that is not an array + pub const ANYCOMPATIBLENONARRAY: Type = Type(Inner::Anycompatiblenonarray); + + /// ANYCOMPATIBLERANGE - pseudo-type representing a range over a polymorphic common type + pub const ANYCOMPATIBLE_RANGE: Type = Type(Inner::AnycompatibleRange); } diff --git a/tokio-postgres/src/error/sqlstate.rs b/tokio-postgres/src/error/sqlstate.rs index 013a2647..3a6ea0bd 100644 --- a/tokio-postgres/src/error/sqlstate.rs +++ b/tokio-postgres/src/error/sqlstate.rs @@ -281,6 +281,10 @@ impl SqlState { /// 22030 pub const DUPLICATE_JSON_OBJECT_KEY_VALUE: SqlState = SqlState(Cow::Borrowed("22030")); + /// 22031 + pub const INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION: SqlState = + SqlState(Cow::Borrowed("22031")); + /// 22032 pub const INVALID_JSON_TEXT: SqlState = SqlState(Cow::Borrowed("22032")); @@ -826,318 +830,319 @@ impl SqlState { #[rustfmt::skip] static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map { - key: 3213172566270843353, + key: 732231254413039614, disps: ::phf::Slice::Static(&[ - (3, 46), (0, 6), - (0, 39), (0, 0), - (0, 192), - (0, 49), - (0, 17), - (1, 138), - (0, 2), - (0, 117), - (0, 0), - (0, 33), - (16, 241), - (0, 20), - (2, 148), - (0, 0), - (0, 1), - (1, 3), - (0, 27), - (0, 21), - (1, 75), - (13, 187), - (0, 3), - (0, 42), - (0, 12), - (0, 82), - (3, 253), - (0, 219), - (0, 6), - (4, 206), - (2, 16), - (5, 67), - (3, 15), - (0, 76), - (0, 57), - (5, 203), - (22, 134), - (1, 27), - (0, 0), - (1, 113), - (0, 0), - (0, 0), - (5, 11), - (0, 45), - (0, 62), - (0, 26), - (1, 158), - (21, 1), - (0, 4), - (5, 64), + (0, 218), + (0, 11), + (0, 31), + (0, 91), + (0, 55), (0, 77), - (1, 189), + (0, 72), + (0, 1), + (0, 73), + (1, 159), + (4, 4), + (0, 18), + (2, 100), + (0, 19), + (0, 16), + (0, 22), + (0, 51), + (0, 0), + (0, 0), + (1, 2), + (2, 177), + (0, 10), + (1, 192), + (0, 0), + (5, 245), + (0, 106), + (6, 243), + (47, 195), + (0, 146), + (4, 154), + (0, 2), + (4, 78), + (0, 196), + (0, 8), + (2, 146), + (0, 15), + (0, 170), + (0, 5), + (10, 18), + (0, 30), + (0, 33), + (0, 2), + (0, 0), + (47, 181), + (0, 144), + (39, 231), + (39, 173), + (0, 57), + (0, 7), + (1, 154), ]), entries: ::phf::Slice::Static(&[ - ("38002", SqlState::E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED), - ("XX002", SqlState::INDEX_CORRUPTED), - ("HV091", SqlState::FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER), - ("42P08", SqlState::AMBIGUOUS_PARAMETER), - ("44000", SqlState::WITH_CHECK_OPTION_VIOLATION), - ("2202E", SqlState::ARRAY_ELEMENT_ERROR), - ("25008", SqlState::HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL), - ("0Z000", SqlState::DIAGNOSTICS_EXCEPTION), + ("22P04", SqlState::BAD_COPY_FILE_FORMAT), + ("39001", SqlState::E_R_I_E_INVALID_SQLSTATE_RETURNED), + ("2201F", SqlState::INVALID_ARGUMENT_FOR_POWER_FUNCTION), + ("54000", SqlState::PROGRAM_LIMIT_EXCEEDED), + ("2200T", SqlState::INVALID_XML_PROCESSING_INSTRUCTION), + ("01000", SqlState::WARNING), + ("02000", SqlState::NO_DATA), + ("40003", SqlState::T_R_STATEMENT_COMPLETION_UNKNOWN), + ("42702", SqlState::AMBIGUOUS_COLUMN), + ("HV000", SqlState::FDW_ERROR), + ("2203A", SqlState::SQL_JSON_MEMBER_NOT_FOUND), + ("22021", SqlState::CHARACTER_NOT_IN_REPERTOIRE), + ("HV006", SqlState::FDW_INVALID_DATA_TYPE_DESCRIPTORS), + ("40000", SqlState::TRANSACTION_ROLLBACK), + ("57P01", SqlState::ADMIN_SHUTDOWN), + ("22034", SqlState::MORE_THAN_ONE_SQL_JSON_ITEM), + ("54023", SqlState::TOO_MANY_ARGUMENTS), + ("22027", SqlState::TRIM_ERROR), + ("2203C", SqlState::SQL_JSON_OBJECT_NOT_FOUND), + ("22P06", SqlState::NONSTANDARD_USE_OF_ESCAPE_CHARACTER), + ("72000", SqlState::SNAPSHOT_TOO_OLD), + ("25004", SqlState::INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION), + ("2BP01", SqlState::DEPENDENT_OBJECTS_STILL_EXIST), + ("42P11", SqlState::INVALID_CURSOR_DEFINITION), + ("HV00J", SqlState::FDW_OPTION_NAME_NOT_FOUND), + ("42804", SqlState::DATATYPE_MISMATCH), + ("39004", SqlState::E_R_I_E_NULL_VALUE_NOT_ALLOWED), + ("42703", SqlState::UNDEFINED_COLUMN), + ("2203E", SqlState::TOO_MANY_JSON_OBJECT_MEMBERS), + ("42P12", SqlState::INVALID_DATABASE_DEFINITION), + ("23503", SqlState::FOREIGN_KEY_VIOLATION), + ("25003", SqlState::INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION), + ("22P03", SqlState::INVALID_BINARY_REPRESENTATION), + ("40002", SqlState::T_R_INTEGRITY_CONSTRAINT_VIOLATION), + ("58030", SqlState::IO_ERROR), + ("01004", SqlState::WARNING_STRING_DATA_RIGHT_TRUNCATION), + ("22019", SqlState::INVALID_ESCAPE_CHARACTER), + ("42P20", SqlState::WINDOWING_ERROR), + ("3D000", SqlState::INVALID_CATALOG_NAME), + ("22001", SqlState::STRING_DATA_RIGHT_TRUNCATION), + ("F0000", SqlState::CONFIG_FILE_ERROR), + ("25005", SqlState::NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION), + ("42883", SqlState::UNDEFINED_FUNCTION), + ("42P06", SqlState::DUPLICATE_SCHEMA), + ("42P17", SqlState::INVALID_OBJECT_DEFINITION), + ("HV002", SqlState::FDW_DYNAMIC_PARAMETER_VALUE_NEEDED), + ("0F001", SqlState::L_E_INVALID_SPECIFICATION), + ("57014", SqlState::QUERY_CANCELED), + ("22033", SqlState::INVALID_SQL_JSON_SUBSCRIPT), + ("2F004", SqlState::S_R_E_READING_SQL_DATA_NOT_PERMITTED), + ("42611", SqlState::INVALID_COLUMN_DEFINITION), + ("42939", SqlState::RESERVED_NAME), + ("0P000", SqlState::INVALID_ROLE_SPECIFICATION), + ("53200", SqlState::OUT_OF_MEMORY), + ("42809", SqlState::WRONG_OBJECT_TYPE), + ("2202H", SqlState::INVALID_TABLESAMPLE_ARGUMENT), + ("42P16", SqlState::INVALID_TABLE_DEFINITION), + ("24000", SqlState::INVALID_CURSOR_STATE), + ("42P13", SqlState::INVALID_FUNCTION_DEFINITION), + ("22007", SqlState::INVALID_DATETIME_FORMAT), + ("2D000", SqlState::INVALID_TRANSACTION_TERMINATION), + ("53100", SqlState::DISK_FULL), + ("P0003", SqlState::TOO_MANY_ROWS), + ("22016", SqlState::INVALID_ARGUMENT_FOR_NTH_VALUE), + ("2F002", SqlState::S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED), + ("42830", SqlState::INVALID_FOREIGN_KEY), + ("27000", SqlState::TRIGGERED_DATA_CHANGE_VIOLATION), + ("0Z002", SqlState::STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER), + ("53000", SqlState::INSUFFICIENT_RESOURCES), + ("23502", SqlState::NOT_NULL_VIOLATION), + ("XX000", SqlState::INTERNAL_ERROR), ("58P01", SqlState::UNDEFINED_FILE), + ("42601", SqlState::SYNTAX_ERROR), + ("02001", SqlState::NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED), + ("42P09", SqlState::AMBIGUOUS_ALIAS), + ("22P02", SqlState::INVALID_TEXT_REPRESENTATION), + ("55P02", SqlState::CANT_CHANGE_RUNTIME_PARAM), + ("2F003", SqlState::S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED), + ("53300", SqlState::TOO_MANY_CONNECTIONS), + ("25P02", SqlState::IN_FAILED_SQL_TRANSACTION), + ("42P03", SqlState::DUPLICATE_CURSOR), + ("XX002", SqlState::INDEX_CORRUPTED), + ("22010", SqlState::INVALID_INDICATOR_PARAMETER_VALUE), + ("01006", SqlState::WARNING_PRIVILEGE_NOT_REVOKED), + ("3B001", SqlState::S_E_INVALID_SPECIFICATION), + ("42P21", SqlState::COLLATION_MISMATCH), + ("42P07", SqlState::DUPLICATE_TABLE), + ("22013", SqlState::INVALID_PRECEDING_OR_FOLLOWING_SIZE), + ("0Z000", SqlState::DIAGNOSTICS_EXCEPTION), + ("55P04", SqlState::UNSAFE_NEW_ENUM_VALUE_USAGE), + ("42000", SqlState::SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION), + ("XX001", SqlState::DATA_CORRUPTED), + ("25008", SqlState::HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL), + ("HV00M", SqlState::FDW_UNABLE_TO_CREATE_REPLY), + ("39000", SqlState::EXTERNAL_ROUTINE_INVOCATION_EXCEPTION), + ("22032", SqlState::INVALID_JSON_TEXT), + ("25006", SqlState::READ_ONLY_SQL_TRANSACTION), + ("01P01", SqlState::WARNING_DEPRECATED_FEATURE), + ("42725", SqlState::AMBIGUOUS_FUNCTION), + ("42602", SqlState::INVALID_NAME), ("2201W", SqlState::INVALID_ROW_COUNT_IN_LIMIT_CLAUSE), ("42P05", SqlState::DUPLICATE_PSTATEMENT), - ("P0001", SqlState::RAISE_EXCEPTION), - ("08P01", SqlState::PROTOCOL_VIOLATION), - ("54000", SqlState::PROGRAM_LIMIT_EXCEEDED), - ("HV014", SqlState::FDW_TOO_MANY_HANDLES), - ("2F003", SqlState::S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED), - ("53200", SqlState::OUT_OF_MEMORY), - ("2200C", SqlState::INVALID_USE_OF_ESCAPE_CHARACTER), - ("25000", SqlState::INVALID_TRANSACTION_STATE), - ("27000", SqlState::TRIGGERED_DATA_CHANGE_VIOLATION), - ("42602", SqlState::INVALID_NAME), - ("08000", SqlState::CONNECTION_EXCEPTION), - ("57P03", SqlState::CANNOT_CONNECT_NOW), - ("2D000", SqlState::INVALID_TRANSACTION_TERMINATION), - ("3B001", SqlState::S_E_INVALID_SPECIFICATION), - ("HV005", SqlState::FDW_COLUMN_NAME_NOT_FOUND), - ("42501", SqlState::INSUFFICIENT_PRIVILEGE), - ("22018", SqlState::INVALID_CHARACTER_VALUE_FOR_CAST), - ("2203D", SqlState::TOO_MANY_JSON_ARRAY_ELEMENTS), - ("P0003", SqlState::TOO_MANY_ROWS), - ("2F005", SqlState::S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT), - ("HV002", SqlState::FDW_DYNAMIC_PARAMETER_VALUE_NEEDED), - ("23505", SqlState::UNIQUE_VIOLATION), - ("38004", SqlState::E_R_E_READING_SQL_DATA_NOT_PERMITTED), - ("22019", SqlState::INVALID_ESCAPE_CHARACTER), - ("2200S", SqlState::INVALID_XML_COMMENT), - ("22030", SqlState::DUPLICATE_JSON_OBJECT_KEY_VALUE), - ("2200G", SqlState::MOST_SPECIFIC_TYPE_MISMATCH), - ("25007", SqlState::SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED), - ("HV024", SqlState::FDW_INVALID_ATTRIBUTE_VALUE), - ("25P03", SqlState::IDLE_IN_TRANSACTION_SESSION_TIMEOUT), - ("0LP01", SqlState::INVALID_GRANT_OPERATION), - ("34000", SqlState::INVALID_CURSOR_NAME), - ("57P02", SqlState::CRASH_SHUTDOWN), - ("22012", SqlState::DIVISION_BY_ZERO), - ("42723", SqlState::DUPLICATE_FUNCTION), - ("22004", SqlState::NULL_VALUE_NOT_ALLOWED), - ("2201X", SqlState::INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE), - ("57000", SqlState::OPERATOR_INTERVENTION), - ("HV008", SqlState::FDW_INVALID_COLUMN_NUMBER), - ("HV00P", SqlState::FDW_NO_SCHEMAS), - ("2203F", SqlState::SQL_JSON_SCALAR_REQUIRED), - ("2201G", SqlState::INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION), - ("23001", SqlState::RESTRICT_VIOLATION), - ("23514", SqlState::CHECK_VIOLATION), - ("42939", SqlState::RESERVED_NAME), - ("25004", SqlState::INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION), - ("HV00K", SqlState::FDW_REPLY_HANDLE), - ("22P06", SqlState::NONSTANDARD_USE_OF_ESCAPE_CHARACTER), - ("53100", SqlState::DISK_FULL), - ("28000", SqlState::INVALID_AUTHORIZATION_SPECIFICATION), - ("03000", SqlState::SQL_STATEMENT_NOT_YET_COMPLETE), - ("72000", SqlState::SNAPSHOT_TOO_OLD), - ("22003", SqlState::NUMERIC_VALUE_OUT_OF_RANGE), - ("25002", SqlState::BRANCH_TRANSACTION_ALREADY_ACTIVE), - ("40002", SqlState::T_R_INTEGRITY_CONSTRAINT_VIOLATION), - ("22013", SqlState::INVALID_PRECEDING_OR_FOLLOWING_SIZE), - ("HV00R", SqlState::FDW_TABLE_NOT_FOUND), - ("2200L", SqlState::NOT_AN_XML_DOCUMENT), - ("25005", SqlState::NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION), - ("25P02", SqlState::IN_FAILED_SQL_TRANSACTION), - ("22007", SqlState::INVALID_DATETIME_FORMAT), - ("26000", SqlState::INVALID_SQL_STATEMENT_NAME), - ("23000", SqlState::INTEGRITY_CONSTRAINT_VIOLATION), - ("42P10", SqlState::INVALID_COLUMN_REFERENCE), - ("2200D", SqlState::INVALID_ESCAPE_OCTET), - ("HV004", SqlState::FDW_INVALID_DATA_TYPE), - ("22005", SqlState::ERROR_IN_ASSIGNMENT), - ("P0002", SqlState::NO_DATA_FOUND), - ("22036", SqlState::NON_NUMERIC_SQL_JSON_ITEM), - ("58030", SqlState::IO_ERROR), - ("HV00Q", SqlState::FDW_SCHEMA_NOT_FOUND), - ("F0001", SqlState::LOCK_FILE_EXISTS), - ("01003", SqlState::WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION), - ("01000", SqlState::WARNING), - ("22032", SqlState::INVALID_JSON_TEXT), - ("2B000", SqlState::DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST), - ("40003", SqlState::T_R_STATEMENT_COMPLETION_UNKNOWN), - ("53400", SqlState::CONFIGURATION_LIMIT_EXCEEDED), - ("2F004", SqlState::S_R_E_READING_SQL_DATA_NOT_PERMITTED), - ("39P03", SqlState::E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED), - ("42846", SqlState::CANNOT_COERCE), - ("39P02", SqlState::E_R_I_E_SRF_PROTOCOL_VIOLATED), - ("23503", SqlState::FOREIGN_KEY_VIOLATION), - ("57P01", SqlState::ADMIN_SHUTDOWN), - ("55P04", SqlState::UNSAFE_NEW_ENUM_VALUE_USAGE), - ("42P19", SqlState::INVALID_RECURSION), - ("53300", SqlState::TOO_MANY_CONNECTIONS), - ("42804", SqlState::DATATYPE_MISMATCH), - ("22015", SqlState::INTERVAL_FIELD_OVERFLOW), - ("0A000", SqlState::FEATURE_NOT_SUPPORTED), - ("0F000", SqlState::LOCATOR_EXCEPTION), - ("42710", SqlState::DUPLICATE_OBJECT), - ("2203C", SqlState::SQL_JSON_OBJECT_NOT_FOUND), - ("P0004", SqlState::ASSERT_FAILURE), - ("22025", SqlState::INVALID_ESCAPE_SEQUENCE), - ("42P17", SqlState::INVALID_OBJECT_DEFINITION), - ("XX000", SqlState::INTERNAL_ERROR), - ("22009", SqlState::INVALID_TIME_ZONE_DISPLACEMENT_VALUE), - ("HV00J", SqlState::FDW_OPTION_NAME_NOT_FOUND), - ("42P11", SqlState::INVALID_CURSOR_DEFINITION), - ("25P01", SqlState::NO_ACTIVE_SQL_TRANSACTION), - ("22034", SqlState::MORE_THAN_ONE_SQL_JSON_ITEM), - ("HV010", SqlState::FDW_FUNCTION_SEQUENCE_ERROR), - ("22P01", SqlState::FLOATING_POINT_EXCEPTION), - ("2F000", SqlState::SQL_ROUTINE_EXCEPTION), - ("21000", SqlState::CARDINALITY_VIOLATION), - ("40001", SqlState::T_R_SERIALIZATION_FAILURE), - ("01P01", SqlState::WARNING_DEPRECATED_FEATURE), - ("22026", SqlState::STRING_DATA_LENGTH_MISMATCH), - ("42P12", SqlState::INVALID_DATABASE_DEFINITION), - ("42704", SqlState::UNDEFINED_OBJECT), - ("42P04", SqlState::DUPLICATE_DATABASE), - ("HV000", SqlState::FDW_ERROR), - ("42P14", SqlState::INVALID_PSTATEMENT_DEFINITION), - ("HV00M", SqlState::FDW_UNABLE_TO_CREATE_REPLY), - ("42701", SqlState::DUPLICATE_COLUMN), - ("55P02", SqlState::CANT_CHANGE_RUNTIME_PARAM), - ("HV090", SqlState::FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH), - ("XX001", SqlState::DATA_CORRUPTED), - ("22038", SqlState::SINGLETON_SQL_JSON_ITEM_REQUIRED), - ("58P02", SqlState::DUPLICATE_FILE), - ("22001", SqlState::STRING_DATA_RIGHT_TRUNCATION), - ("08003", SqlState::CONNECTION_DOES_NOT_EXIST), - ("39000", SqlState::EXTERNAL_ROUTINE_INVOCATION_EXCEPTION), - ("HV00B", SqlState::FDW_INVALID_HANDLE), - ("54011", SqlState::TOO_MANY_COLUMNS), - ("0Z002", SqlState::STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER), - ("2203E", SqlState::TOO_MANY_JSON_OBJECT_MEMBERS), - ("23P01", SqlState::EXCLUSION_VIOLATION), - ("HV006", SqlState::FDW_INVALID_DATA_TYPE_DESCRIPTORS), - ("39004", SqlState::E_R_I_E_NULL_VALUE_NOT_ALLOWED), - ("HV009", SqlState::FDW_INVALID_USE_OF_NULL_POINTER), - ("22035", SqlState::NO_SQL_JSON_ITEM), - ("HV001", SqlState::FDW_OUT_OF_MEMORY), - ("3F000", SqlState::INVALID_SCHEMA_NAME), - ("0B000", SqlState::INVALID_TRANSACTION_INITIATION), - ("42830", SqlState::INVALID_FOREIGN_KEY), - ("01007", SqlState::WARNING_PRIVILEGE_NOT_GRANTED), - ("2201F", SqlState::INVALID_ARGUMENT_FOR_POWER_FUNCTION), - ("54023", SqlState::TOO_MANY_ARGUMENTS), - ("09000", SqlState::TRIGGERED_ACTION_EXCEPTION), - ("2200H", SqlState::SEQUENCE_GENERATOR_LIMIT_EXCEEDED), - ("428C9", SqlState::GENERATED_ALWAYS), - ("53000", SqlState::INSUFFICIENT_RESOURCES), - ("42P09", SqlState::AMBIGUOUS_ALIAS), - ("08006", SqlState::CONNECTION_FAILURE), - ("22039", SqlState::SQL_JSON_ARRAY_NOT_FOUND), - ("54001", SqlState::STATEMENT_TOO_COMPLEX), - ("2203A", SqlState::SQL_JSON_MEMBER_NOT_FOUND), - ("23502", SqlState::NOT_NULL_VIOLATION), - ("22008", SqlState::DATETIME_FIELD_OVERFLOW), - ("F0000", SqlState::CONFIG_FILE_ERROR), - ("3B000", SqlState::SAVEPOINT_EXCEPTION), - ("2BP01", SqlState::DEPENDENT_OBJECTS_STILL_EXIST), - ("2202H", SqlState::INVALID_TABLESAMPLE_ARGUMENT), - ("38001", SqlState::E_R_E_CONTAINING_SQL_NOT_PERMITTED), - ("01004", SqlState::WARNING_STRING_DATA_RIGHT_TRUNCATION), - ("57014", SqlState::QUERY_CANCELED), - ("55000", SqlState::OBJECT_NOT_IN_PREREQUISITE_STATE), - ("40000", SqlState::TRANSACTION_ROLLBACK), - ("HV00L", SqlState::FDW_UNABLE_TO_CREATE_EXECUTION), - ("22033", SqlState::INVALID_SQL_JSON_SUBSCRIPT), - ("02000", SqlState::NO_DATA), - ("2200T", SqlState::INVALID_XML_PROCESSING_INSTRUCTION), - ("3D000", SqlState::INVALID_CATALOG_NAME), - ("2200M", SqlState::INVALID_XML_DOCUMENT), - ("42611", SqlState::INVALID_COLUMN_DEFINITION), - ("2F002", SqlState::S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED), - ("22P05", SqlState::UNTRANSLATABLE_CHARACTER), - ("42883", SqlState::UNDEFINED_FUNCTION), - ("22016", SqlState::INVALID_ARGUMENT_FOR_NTH_VALUE), - ("22027", SqlState::TRIM_ERROR), - ("39P01", SqlState::E_R_I_E_TRIGGER_PROTOCOL_VIOLATED), - ("0L000", SqlState::INVALID_GRANTOR), - ("42725", SqlState::AMBIGUOUS_FUNCTION), - ("42601", SqlState::SYNTAX_ERROR), - ("22002", SqlState::NULL_VALUE_NO_INDICATOR_PARAMETER), - ("42702", SqlState::AMBIGUOUS_COLUMN), - ("22024", SqlState::UNTERMINATED_C_STRING), - ("22023", SqlState::INVALID_PARAMETER_VALUE), - ("22P03", SqlState::INVALID_BINARY_REPRESENTATION), - ("22010", SqlState::INVALID_INDICATOR_PARAMETER_VALUE), - ("42P16", SqlState::INVALID_TABLE_DEFINITION), - ("0P000", SqlState::INVALID_ROLE_SPECIFICATION), - ("2203B", SqlState::SQL_JSON_NUMBER_NOT_FOUND), - ("55006", SqlState::OBJECT_IN_USE), - ("42P13", SqlState::INVALID_FUNCTION_DEFINITION), - ("42803", SqlState::GROUPING_ERROR), - ("22021", SqlState::CHARACTER_NOT_IN_REPERTOIRE), - ("08004", SqlState::SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION), - ("42P15", SqlState::INVALID_SCHEMA_DEFINITION), - ("25006", SqlState::READ_ONLY_SQL_TRANSACTION), - ("42P02", SqlState::UNDEFINED_PARAMETER), - ("2201E", SqlState::INVALID_ARGUMENT_FOR_LOG), - ("42P22", SqlState::INDETERMINATE_COLLATION), - ("0F001", SqlState::L_E_INVALID_SPECIFICATION), - ("2201B", SqlState::INVALID_REGULAR_EXPRESSION), - ("08001", SqlState::SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION), - ("42P07", SqlState::DUPLICATE_TABLE), - ("02001", SqlState::NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED), - ("58000", SqlState::SYSTEM_ERROR), - ("42000", SqlState::SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION), - ("42622", SqlState::NAME_TOO_LONG), - ("20000", SqlState::CASE_NOT_FOUND), - ("08007", SqlState::TRANSACTION_RESOLUTION_UNKNOWN), - ("22022", SqlState::INDICATOR_OVERFLOW), - ("42P18", SqlState::INDETERMINATE_DATATYPE), - ("01008", SqlState::WARNING_IMPLICIT_ZERO_BIT_PADDING), - ("39001", SqlState::E_R_I_E_INVALID_SQLSTATE_RETURNED), - ("22014", SqlState::INVALID_ARGUMENT_FOR_NTILE), - ("2200N", SqlState::INVALID_XML_CONTENT), - ("42P01", SqlState::UNDEFINED_TABLE), - ("42P03", SqlState::DUPLICATE_CURSOR), - ("25003", SqlState::INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION), - ("22037", SqlState::NON_UNIQUE_KEYS_IN_A_JSON_OBJECT), - ("22000", SqlState::DATA_EXCEPTION), - ("28P01", SqlState::INVALID_PASSWORD), - ("HV00A", SqlState::FDW_INVALID_STRING_FORMAT), - ("42P06", SqlState::DUPLICATE_SCHEMA), - ("HV00D", SqlState::FDW_INVALID_OPTION_NAME), - ("55P03", SqlState::LOCK_NOT_AVAILABLE), ("HV021", SqlState::FDW_INCONSISTENT_DESCRIPTOR_INFORMATION), - ("42712", SqlState::DUPLICATE_ALIAS), - ("38000", SqlState::EXTERNAL_ROUTINE_EXCEPTION), - ("HV00N", SqlState::FDW_UNABLE_TO_ESTABLISH_CONNECTION), - ("2200B", SqlState::ESCAPE_CHARACTER_CONFLICT), - ("42P21", SqlState::COLLATION_MISMATCH), - ("42703", SqlState::UNDEFINED_COLUMN), - ("57P04", SqlState::DATABASE_DROPPED), - ("22P04", SqlState::BAD_COPY_FILE_FORMAT), - ("01006", SqlState::WARNING_PRIVILEGE_NOT_REVOKED), - ("HV007", SqlState::FDW_INVALID_COLUMN_NAME), - ("HV00C", SqlState::FDW_INVALID_OPTION_INDEX), - ("25001", SqlState::ACTIVE_SQL_TRANSACTION), - ("42809", SqlState::WRONG_OBJECT_TYPE), - ("22P02", SqlState::INVALID_TEXT_REPRESENTATION), - ("42P20", SqlState::WINDOWING_ERROR), - ("24000", SqlState::INVALID_CURSOR_STATE), - ("22011", SqlState::SUBSTRING_ERROR), - ("00000", SqlState::SUCCESSFUL_COMPLETION), - ("2202G", SqlState::INVALID_TABLESAMPLE_REPEAT), - ("P0000", SqlState::PLPGSQL_ERROR), - ("38003", SqlState::E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED), + ("57P03", SqlState::CANNOT_CONNECT_NOW), + ("58P02", SqlState::DUPLICATE_FILE), + ("42P22", SqlState::INDETERMINATE_COLLATION), + ("0B000", SqlState::INVALID_TRANSACTION_INITIATION), ("0100C", SqlState::WARNING_DYNAMIC_RESULT_SETS_RETURNED), + ("22015", SqlState::INTERVAL_FIELD_OVERFLOW), + ("2200S", SqlState::INVALID_XML_COMMENT), + ("2200M", SqlState::INVALID_XML_DOCUMENT), + ("HV001", SqlState::FDW_OUT_OF_MEMORY), + ("25001", SqlState::ACTIVE_SQL_TRANSACTION), + ("22002", SqlState::NULL_VALUE_NO_INDICATOR_PARAMETER), + ("2F005", SqlState::S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT), + ("428C9", SqlState::GENERATED_ALWAYS), + ("25P01", SqlState::NO_ACTIVE_SQL_TRANSACTION), + ("HV091", SqlState::FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER), + ("2200C", SqlState::INVALID_USE_OF_ESCAPE_CHARACTER), + ("HV008", SqlState::FDW_INVALID_COLUMN_NUMBER), ("2200F", SqlState::ZERO_LENGTH_CHARACTER_STRING), + ("54001", SqlState::STATEMENT_TOO_COMPLEX), + ("42712", SqlState::DUPLICATE_ALIAS), + ("HV00A", SqlState::FDW_INVALID_STRING_FORMAT), + ("42710", SqlState::DUPLICATE_OBJECT), + ("54011", SqlState::TOO_MANY_COLUMNS), + ("42P19", SqlState::INVALID_RECURSION), + ("42501", SqlState::INSUFFICIENT_PRIVILEGE), + ("57000", SqlState::OPERATOR_INTERVENTION), + ("25002", SqlState::BRANCH_TRANSACTION_ALREADY_ACTIVE), + ("22039", SqlState::SQL_JSON_ARRAY_NOT_FOUND), + ("P0002", SqlState::NO_DATA_FOUND), + ("2201G", SqlState::INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION), + ("22012", SqlState::DIVISION_BY_ZERO), + ("42P10", SqlState::INVALID_COLUMN_REFERENCE), + ("HV00B", SqlState::FDW_INVALID_HANDLE), + ("38003", SqlState::E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED), + ("25P03", SqlState::IDLE_IN_TRANSACTION_SESSION_TIMEOUT), + ("F0001", SqlState::LOCK_FILE_EXISTS), + ("08001", SqlState::SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION), + ("2203D", SqlState::TOO_MANY_JSON_ARRAY_ELEMENTS), + ("P0000", SqlState::PLPGSQL_ERROR), + ("28000", SqlState::INVALID_AUTHORIZATION_SPECIFICATION), + ("2200D", SqlState::INVALID_ESCAPE_OCTET), + ("55P03", SqlState::LOCK_NOT_AVAILABLE), + ("23505", SqlState::UNIQUE_VIOLATION), + ("39P01", SqlState::E_R_I_E_TRIGGER_PROTOCOL_VIOLATED), + ("44000", SqlState::WITH_CHECK_OPTION_VIOLATION), + ("22030", SqlState::DUPLICATE_JSON_OBJECT_KEY_VALUE), + ("P0004", SqlState::ASSERT_FAILURE), + ("2200G", SqlState::MOST_SPECIFIC_TYPE_MISMATCH), + ("2F000", SqlState::SQL_ROUTINE_EXCEPTION), + ("26000", SqlState::INVALID_SQL_STATEMENT_NAME), + ("2202G", SqlState::INVALID_TABLESAMPLE_REPEAT), + ("22003", SqlState::NUMERIC_VALUE_OUT_OF_RANGE), + ("21000", SqlState::CARDINALITY_VIOLATION), + ("0A000", SqlState::FEATURE_NOT_SUPPORTED), + ("HV014", SqlState::FDW_TOO_MANY_HANDLES), + ("08004", SqlState::SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION), + ("38001", SqlState::E_R_E_CONTAINING_SQL_NOT_PERMITTED), + ("01003", SqlState::WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION), + ("08007", SqlState::TRANSACTION_RESOLUTION_UNKNOWN), + ("HV00D", SqlState::FDW_INVALID_OPTION_NAME), + ("38002", SqlState::E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED), + ("HV00K", SqlState::FDW_REPLY_HANDLE), + ("23P01", SqlState::EXCLUSION_VIOLATION), + ("42P04", SqlState::DUPLICATE_DATABASE), + ("22025", SqlState::INVALID_ESCAPE_SEQUENCE), + ("HV007", SqlState::FDW_INVALID_COLUMN_NAME), + ("34000", SqlState::INVALID_CURSOR_NAME), + ("HV00L", SqlState::FDW_UNABLE_TO_CREATE_EXECUTION), + ("HV009", SqlState::FDW_INVALID_USE_OF_NULL_POINTER), + ("38000", SqlState::EXTERNAL_ROUTINE_EXCEPTION), + ("2B000", SqlState::DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST), + ("00000", SqlState::SUCCESSFUL_COMPLETION), + ("58000", SqlState::SYSTEM_ERROR), + ("2201E", SqlState::INVALID_ARGUMENT_FOR_LOG), + ("HV024", SqlState::FDW_INVALID_ATTRIBUTE_VALUE), + ("2200L", SqlState::NOT_AN_XML_DOCUMENT), + ("2203B", SqlState::SQL_JSON_NUMBER_NOT_FOUND), + ("42846", SqlState::CANNOT_COERCE), + ("22035", SqlState::NO_SQL_JSON_ITEM), + ("HV005", SqlState::FDW_COLUMN_NAME_NOT_FOUND), + ("20000", SqlState::CASE_NOT_FOUND), + ("40001", SqlState::T_R_SERIALIZATION_FAILURE), + ("22000", SqlState::DATA_EXCEPTION), + ("22038", SqlState::SINGLETON_SQL_JSON_ITEM_REQUIRED), + ("42P14", SqlState::INVALID_PSTATEMENT_DEFINITION), + ("39P02", SqlState::E_R_I_E_SRF_PROTOCOL_VIOLATED), + ("01008", SqlState::WARNING_IMPLICIT_ZERO_BIT_PADDING), + ("42P15", SqlState::INVALID_SCHEMA_DEFINITION), + ("55006", SqlState::OBJECT_IN_USE), + ("2203F", SqlState::SQL_JSON_SCALAR_REQUIRED), + ("22014", SqlState::INVALID_ARGUMENT_FOR_NTILE), + ("03000", SqlState::SQL_STATEMENT_NOT_YET_COMPLETE), + ("22008", SqlState::DATETIME_FIELD_OVERFLOW), + ("08006", SqlState::CONNECTION_FAILURE), + ("42P01", SqlState::UNDEFINED_TABLE), ("40P01", SqlState::T_R_DEADLOCK_DETECTED), + ("0L000", SqlState::INVALID_GRANTOR), + ("22005", SqlState::ERROR_IN_ASSIGNMENT), + ("42622", SqlState::NAME_TOO_LONG), + ("57P04", SqlState::DATABASE_DROPPED), + ("42803", SqlState::GROUPING_ERROR), + ("22P01", SqlState::FLOATING_POINT_EXCEPTION), + ("42P18", SqlState::INDETERMINATE_DATATYPE), + ("38004", SqlState::E_R_E_READING_SQL_DATA_NOT_PERMITTED), + ("39P03", SqlState::E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED), + ("2200N", SqlState::INVALID_XML_CONTENT), + ("57P02", SqlState::CRASH_SHUTDOWN), + ("23000", SqlState::INTEGRITY_CONSTRAINT_VIOLATION), + ("0F000", SqlState::LOCATOR_EXCEPTION), + ("08000", SqlState::CONNECTION_EXCEPTION), + ("2202E", SqlState::ARRAY_ELEMENT_ERROR), + ("22024", SqlState::UNTERMINATED_C_STRING), + ("08P01", SqlState::PROTOCOL_VIOLATION), + ("22023", SqlState::INVALID_PARAMETER_VALUE), + ("22031", SqlState::INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION), + ("HV00P", SqlState::FDW_NO_SCHEMAS), + ("23514", SqlState::CHECK_VIOLATION), + ("HV00Q", SqlState::FDW_SCHEMA_NOT_FOUND), + ("22P05", SqlState::UNTRANSLATABLE_CHARACTER), + ("53400", SqlState::CONFIGURATION_LIMIT_EXCEEDED), + ("3F000", SqlState::INVALID_SCHEMA_NAME), + ("22037", SqlState::NON_UNIQUE_KEYS_IN_A_JSON_OBJECT), + ("22004", SqlState::NULL_VALUE_NOT_ALLOWED), + ("2200B", SqlState::ESCAPE_CHARACTER_CONFLICT), + ("HV090", SqlState::FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH), + ("HV00R", SqlState::FDW_TABLE_NOT_FOUND), + ("42723", SqlState::DUPLICATE_FUNCTION), + ("22009", SqlState::INVALID_TIME_ZONE_DISPLACEMENT_VALUE), + ("HV00N", SqlState::FDW_UNABLE_TO_ESTABLISH_CONNECTION), + ("3B000", SqlState::SAVEPOINT_EXCEPTION), + ("22018", SqlState::INVALID_CHARACTER_VALUE_FOR_CAST), + ("HV004", SqlState::FDW_INVALID_DATA_TYPE), + ("08003", SqlState::CONNECTION_DOES_NOT_EXIST), + ("42P02", SqlState::UNDEFINED_PARAMETER), + ("23001", SqlState::RESTRICT_VIOLATION), + ("HV00C", SqlState::FDW_INVALID_OPTION_INDEX), + ("HV010", SqlState::FDW_FUNCTION_SEQUENCE_ERROR), + ("28P01", SqlState::INVALID_PASSWORD), + ("55000", SqlState::OBJECT_NOT_IN_PREREQUISITE_STATE), + ("2201X", SqlState::INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE), + ("P0001", SqlState::RAISE_EXCEPTION), + ("25000", SqlState::INVALID_TRANSACTION_STATE), + ("42704", SqlState::UNDEFINED_OBJECT), + ("22022", SqlState::INDICATOR_OVERFLOW), + ("09000", SqlState::TRIGGERED_ACTION_EXCEPTION), + ("22026", SqlState::STRING_DATA_LENGTH_MISMATCH), + ("01007", SqlState::WARNING_PRIVILEGE_NOT_GRANTED), + ("2200H", SqlState::SEQUENCE_GENERATOR_LIMIT_EXCEEDED), + ("25007", SqlState::SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED), + ("42701", SqlState::DUPLICATE_COLUMN), + ("42P08", SqlState::AMBIGUOUS_PARAMETER), + ("2201B", SqlState::INVALID_REGULAR_EXPRESSION), + ("22036", SqlState::NON_NUMERIC_SQL_JSON_ITEM), + ("22011", SqlState::SUBSTRING_ERROR), + ("0LP01", SqlState::INVALID_GRANT_OPERATION), ]), };