dnim/rust-postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Run clippy

Browse Source
This commit is contained in:
Steven Fackler 2018-12-09 21:23:31 -08:00
parent 8c3338e37d
commit 04ce4bb7a1
29 changed files with 642 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.circleci/config.yml
View File

@ -28,8 +28,9 @@ jobs:
- image: sfackler/rust-postgres-test:5 - image: sfackler/rust-postgres-test:5
steps: steps:
- checkout - checkout
- run: rustup component add rustfmt - run: rustup component add rustfmt clippy
- run: cargo fmt --all -- --check - run: cargo fmt --all -- --check
- run: cargo clippy --all
- *RESTORE_REGISTRY - *RESTORE_REGISTRY
- run: cargo generate-lockfile - run: cargo generate-lockfile
- *SAVE_REGISTRY - *SAVE_REGISTRY

2
codegen/src/main.rs
View File

@ -1,3 +1,5 @@
#![warn(clippy::all)]
extern crate linked_hash_map; extern crate linked_hash_map;
extern crate marksman_escape; extern crate marksman_escape;
extern crate phf_codegen; extern crate phf_codegen;

7
codegen/src/sqlstate.rs
View File

@ -4,7 +4,7 @@ use std::fs::File;
use std::io::{BufWriter, Write}; use std::io::{BufWriter, Write};
use std::path::Path; use std::path::Path;
const ERRCODES_TXT: &'static str = include_str!("errcodes.txt"); const ERRCODES_TXT: &str = include_str!("errcodes.txt");
pub fn build(path: &Path) { pub fn build(path: &Path) {
let mut file = BufWriter::new(File::create(path.join("error/sqlstate.rs")).unwrap()); let mut file = BufWriter::new(File::create(path.join("error/sqlstate.rs")).unwrap());
@ -20,7 +20,7 @@ fn parse_codes() -> LinkedHashMap<String, Vec<String>> {
let mut codes = LinkedHashMap::new(); let mut codes = LinkedHashMap::new();
for line in ERRCODES_TXT.lines() { for line in ERRCODES_TXT.lines() {
if line.starts_with("#") || line.starts_with("Section") || line.trim().is_empty() { if line.starts_with('#') || line.starts_with("Section") || line.trim().is_empty() {
continue; continue;
} }
@ -39,7 +39,6 @@ fn make_type(file: &mut BufWriter<File>) {
write!( write!(
file, file,
"// Autogenerated file - DO NOT EDIT "// Autogenerated file - DO NOT EDIT
use phf;
use std::borrow::Cow; use std::borrow::Cow;
/// A SQLSTATE error code /// A SQLSTATE error code
@ -96,5 +95,5 @@ static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = "
builder.entry(&**code, &format!("SqlState::{}", &names[0])); builder.entry(&**code, &format!("SqlState::{}", &names[0]));
} }
builder.build(file).unwrap(); builder.build(file).unwrap();
write!(file, ";\n").unwrap(); writeln!(file, ";").unwrap();
} }

9
codegen/src/type_gen.rs
View File

@ -7,8 +7,8 @@ use std::path::Path;
use crate::snake_to_camel; use crate::snake_to_camel;
const PG_TYPE_H: &'static str = include_str!("pg_type.h"); const PG_TYPE_H: &str = include_str!("pg_type.h");
const PG_RANGE_H: &'static str = include_str!("pg_range.h"); const PG_RANGE_H: &str = include_str!("pg_range.h");
struct Type { struct Type {
name: &'static str, name: &'static str,
@ -122,7 +122,7 @@ fn make_header(w: &mut BufWriter<File>) {
"// Autogenerated file - DO NOT EDIT "// Autogenerated file - DO NOT EDIT
use std::sync::Arc; use std::sync::Arc;
use types::{{Type, Oid, Kind}}; use crate::types::{{Type, Oid, Kind}};
#[derive(PartialEq, Eq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct Other {{ pub struct Other {{
@ -231,8 +231,7 @@ fn make_impl(w: &mut BufWriter<File>, types: &BTreeMap<u32, Type>) {
write!( write!(
w, w,
" Inner::{} => {{ " Inner::{} => {{
const V: &'static Kind = &Kind::{}; &Kind::{}
V
}} }}
", ",
type_.variant, kind type_.variant, kind

18
postgres-protocol/src/authentication/sasl.rs
View File

@ -14,9 +14,9 @@ use std::str;
const NONCE_LENGTH: usize = 24; const NONCE_LENGTH: usize = 24;
/// The identifier of the SCRAM-SHA-256 SASL authentication mechanism. /// The identifier of the SCRAM-SHA-256 SASL authentication mechanism.
pub const SCRAM_SHA_256: &'static str = "SCRAM-SHA-256"; pub const SCRAM_SHA_256: &str = "SCRAM-SHA-256";
/// The identifier of the SCRAM-SHA-256-PLUS SASL authentication mechanism. /// The identifier of the SCRAM-SHA-256-PLUS SASL authentication mechanism.
pub const SCRAM_SHA_256_PLUS: &'static str = "SCRAM-SHA-256-PLUS"; pub const SCRAM_SHA_256_PLUS: &str = "SCRAM-SHA-256-PLUS";
// since postgres passwords are not required to exclude saslprep-prohibited // since postgres passwords are not required to exclude saslprep-prohibited
// characters or even be valid UTF8, we run saslprep if possible and otherwise // characters or even be valid UTF8, we run saslprep if possible and otherwise
@ -153,7 +153,7 @@ impl ScramSha256 {
state: State::Update { state: State::Update {
nonce, nonce,
password: normalize(password), password: normalize(password),
channel_binding: channel_binding, channel_binding,
}, },
} }
} }
@ -228,8 +228,8 @@ impl ScramSha256 {
write!(&mut self.message, ",p={}", base64::encode(&*client_proof)).unwrap(); write!(&mut self.message, ",p={}", base64::encode(&*client_proof)).unwrap();
self.state = State::Finish { self.state = State::Finish {
salted_password: salted_password, salted_password,
auth_message: auth_message, auth_message,
}; };
Ok(()) Ok(())
} }
@ -288,7 +288,7 @@ struct Parser<'a> {
impl<'a> Parser<'a> { impl<'a> Parser<'a> {
fn new(s: &'a str) -> Parser<'a> { fn new(s: &'a str) -> Parser<'a> {
Parser { Parser {
s: s, s,
it: s.char_indices().peekable(), it: s.char_indices().peekable(),
} }
} }
@ -390,9 +390,9 @@ impl<'a> Parser<'a> {
self.eof()?; self.eof()?;
Ok(ServerFirstMessage { Ok(ServerFirstMessage {
nonce: nonce, nonce,
salt: salt, salt,
iteration_count: iteration_count, iteration_count,
}) })
} }

2
postgres-protocol/src/lib.rs
View File

@ -10,7 +10,7 @@
//! This library assumes that the `client_encoding` backend parameter has been //! This library assumes that the `client_encoding` backend parameter has been
//! set to `UTF8`. It will most likely not behave properly if that is not the case. //! set to `UTF8`. It will most likely not behave properly if that is not the case.
#![doc(html_root_url = "https://docs.rs/postgres-protocol/0.3")] #![doc(html_root_url = "https://docs.rs/postgres-protocol/0.3")]
#![warn(missing_docs, rust_2018_idioms)] #![warn(missing_docs, rust_2018_idioms, clippy::all)]
use byteorder::{BigEndian, ByteOrder}; use byteorder::{BigEndian, ByteOrder};
use std::io; use std::io;

89
postgres-protocol/src/message/backend.rs
View File

@ -88,40 +88,37 @@ impl Message {
let channel = buf.read_cstr()?; let channel = buf.read_cstr()?;
let message = buf.read_cstr()?; let message = buf.read_cstr()?;
Message::NotificationResponse(NotificationResponseBody { Message::NotificationResponse(NotificationResponseBody {
process_id: process_id, process_id,
channel: channel, channel,
message: message, message,
}) })
} }
b'c' => Message::CopyDone, b'c' => Message::CopyDone,
b'C' => { b'C' => {
let tag = buf.read_cstr()?; let tag = buf.read_cstr()?;
Message::CommandComplete(CommandCompleteBody { tag: tag }) Message::CommandComplete(CommandCompleteBody { tag })
} }
b'd' => { b'd' => {
let storage = buf.read_all(); let storage = buf.read_all();
Message::CopyData(CopyDataBody { storage: storage }) Message::CopyData(CopyDataBody { storage })
} }
b'D' => { b'D' => {
let len = buf.read_u16::<BigEndian>()?; let len = buf.read_u16::<BigEndian>()?;
let storage = buf.read_all(); let storage = buf.read_all();
Message::DataRow(DataRowBody { Message::DataRow(DataRowBody { storage, len })
storage: storage,
len: len,
})
} }
b'E' => { b'E' => {
let storage = buf.read_all(); let storage = buf.read_all();
Message::ErrorResponse(ErrorResponseBody { storage: storage }) Message::ErrorResponse(ErrorResponseBody { storage })
} }
b'G' => { b'G' => {
let format = buf.read_u8()?; let format = buf.read_u8()?;
let len = buf.read_u16::<BigEndian>()?; let len = buf.read_u16::<BigEndian>()?;
let storage = buf.read_all(); let storage = buf.read_all();
Message::CopyInResponse(CopyInResponseBody { Message::CopyInResponse(CopyInResponseBody {
format: format, format,
len: len, len,
storage: storage, storage,
}) })
} }
b'H' => { b'H' => {
@ -129,9 +126,9 @@ impl Message {
let len = buf.read_u16::<BigEndian>()?; let len = buf.read_u16::<BigEndian>()?;
let storage = buf.read_all(); let storage = buf.read_all();
Message::CopyOutResponse(CopyOutResponseBody { Message::CopyOutResponse(CopyOutResponseBody {
format: format, format,
len: len, len,
storage: storage, storage,
}) })
} }
b'I' => Message::EmptyQueryResponse, b'I' => Message::EmptyQueryResponse,
@ -139,14 +136,14 @@ impl Message {
let process_id = buf.read_i32::<BigEndian>()?; let process_id = buf.read_i32::<BigEndian>()?;
let secret_key = buf.read_i32::<BigEndian>()?; let secret_key = buf.read_i32::<BigEndian>()?;
Message::BackendKeyData(BackendKeyDataBody { Message::BackendKeyData(BackendKeyDataBody {
process_id: process_id, process_id,
secret_key: secret_key, secret_key,
}) })
} }
b'n' => Message::NoData, b'n' => Message::NoData,
b'N' => { b'N' => {
let storage = buf.read_all(); let storage = buf.read_all();
Message::NoticeResponse(NoticeResponseBody { storage: storage }) Message::NoticeResponse(NoticeResponseBody { storage })
} }
b'R' => match buf.read_i32::<BigEndian>()? { b'R' => match buf.read_i32::<BigEndian>()? {
0 => Message::AuthenticationOk, 0 => Message::AuthenticationOk,
@ -155,7 +152,7 @@ impl Message {
5 => { 5 => {
let mut salt = [0; 4]; let mut salt = [0; 4];
buf.read_exact(&mut salt)?; buf.read_exact(&mut salt)?;
Message::AuthenticationMd5Password(AuthenticationMd5PasswordBody { salt: salt }) Message::AuthenticationMd5Password(AuthenticationMd5PasswordBody { salt })
} }
6 => Message::AuthenticationScmCredential, 6 => Message::AuthenticationScmCredential,
7 => Message::AuthenticationGss, 7 => Message::AuthenticationGss,
@ -187,30 +184,21 @@ impl Message {
b'S' => { b'S' => {
let name = buf.read_cstr()?; let name = buf.read_cstr()?;
let value = buf.read_cstr()?; let value = buf.read_cstr()?;
Message::ParameterStatus(ParameterStatusBody { Message::ParameterStatus(ParameterStatusBody { name, value })
name: name,
value: value,
})
} }
b't' => { b't' => {
let len = buf.read_u16::<BigEndian>()?; let len = buf.read_u16::<BigEndian>()?;
let storage = buf.read_all(); let storage = buf.read_all();
Message::ParameterDescription(ParameterDescriptionBody { Message::ParameterDescription(ParameterDescriptionBody { storage, len })
storage: storage,
len: len,
})
} }
b'T' => { b'T' => {
let len = buf.read_u16::<BigEndian>()?; let len = buf.read_u16::<BigEndian>()?;
let storage = buf.read_all(); let storage = buf.read_all();
Message::RowDescription(RowDescriptionBody { Message::RowDescription(RowDescriptionBody { storage, len })
storage: storage,
len: len,
})
} }
b'Z' => { b'Z' => {
let status = buf.read_u8()?; let status = buf.read_u8()?;
Message::ReadyForQuery(ReadyForQueryBody { status: status }) Message::ReadyForQuery(ReadyForQueryBody { status })
} }
tag => { tag => {
return Err(io::Error::new( return Err(io::Error::new(
@ -305,7 +293,7 @@ pub struct AuthenticationSaslBody(Bytes);
impl AuthenticationSaslBody { impl AuthenticationSaslBody {
#[inline] #[inline]
pub fn mechanisms<'a>(&'a self) -> SaslMechanisms<'a> { pub fn mechanisms(&self) -> SaslMechanisms<'_> {
SaslMechanisms(&self.0) SaslMechanisms(&self.0)
} }
} }
@ -410,7 +398,7 @@ impl CopyInResponseBody {
} }
#[inline] #[inline]
pub fn column_formats<'a>(&'a self) -> ColumnFormats<'a> { pub fn column_formats(&self) -> ColumnFormats<'_> {
ColumnFormats { ColumnFormats {
remaining: self.len, remaining: self.len,
buf: &self.storage, buf: &self.storage,
@ -464,7 +452,7 @@ impl CopyOutResponseBody {
} }
#[inline] #[inline]
pub fn column_formats<'a>(&'a self) -> ColumnFormats<'a> { pub fn column_formats(&self) -> ColumnFormats<'_> {
ColumnFormats { ColumnFormats {
remaining: self.len, remaining: self.len,
buf: &self.storage, buf: &self.storage,
@ -479,7 +467,7 @@ pub struct DataRowBody {
impl DataRowBody { impl DataRowBody {
#[inline] #[inline]
pub fn ranges<'a>(&'a self) -> DataRowRanges<'a> { pub fn ranges(&self) -> DataRowRanges<'_> {
DataRowRanges { DataRowRanges {
buf: &self.storage, buf: &self.storage,
len: self.storage.len(), len: self.storage.len(),
@ -547,7 +535,7 @@ pub struct ErrorResponseBody {
impl ErrorResponseBody { impl ErrorResponseBody {
#[inline] #[inline]
pub fn fields<'a>(&'a self) -> ErrorFields<'a> { pub fn fields(&self) -> ErrorFields<'_> {
ErrorFields { buf: &self.storage } ErrorFields { buf: &self.storage }
} }
} }
@ -578,10 +566,7 @@ impl<'a> FallibleIterator for ErrorFields<'a> {
let value = get_str(&self.buf[..value_end])?; let value = get_str(&self.buf[..value_end])?;
self.buf = &self.buf[value_end + 1..]; self.buf = &self.buf[value_end + 1..];
Ok(Some(ErrorField { Ok(Some(ErrorField { type_, value }))
type_: type_,
value: value,
}))
} }
} }
@ -608,7 +593,7 @@ pub struct NoticeResponseBody {
impl NoticeResponseBody { impl NoticeResponseBody {
#[inline] #[inline]
pub fn fields<'a>(&'a self) -> ErrorFields<'a> { pub fn fields(&self) -> ErrorFields<'_> {
ErrorFields { buf: &self.storage } ErrorFields { buf: &self.storage }
} }
} }
@ -643,7 +628,7 @@ pub struct ParameterDescriptionBody {
impl ParameterDescriptionBody { impl ParameterDescriptionBody {
#[inline] #[inline]
pub fn parameters<'a>(&'a self) -> Parameters<'a> { pub fn parameters(&self) -> Parameters<'_> {
Parameters { Parameters {
buf: &self.storage, buf: &self.storage,
remaining: self.len, remaining: self.len,
@ -719,7 +704,7 @@ pub struct RowDescriptionBody {
impl RowDescriptionBody { impl RowDescriptionBody {
#[inline] #[inline]
pub fn fields<'a>(&'a self) -> Fields<'a> { pub fn fields(&self) -> Fields<'_> {
Fields { Fields {
buf: &self.storage, buf: &self.storage,
remaining: self.len, remaining: self.len,
@ -761,13 +746,13 @@ impl<'a> FallibleIterator for Fields<'a> {
let format = self.buf.read_i16::<BigEndian>()?; let format = self.buf.read_i16::<BigEndian>()?;
Ok(Some(Field { Ok(Some(Field {
name: name, name,
table_oid: table_oid, table_oid,
column_id: column_id, column_id,
type_oid: type_oid, type_oid,
type_size: type_size, type_size,
type_modifier: type_modifier, type_modifier,
format: format, format,
})) }))
} }
} }

40
postgres-protocol/src/message/frontend.rs
View File

@ -102,10 +102,16 @@ impl<'a> Message<'a> {
Message::CancelRequest { Message::CancelRequest {
process_id, process_id,
secret_key, secret_key,
} => Ok(cancel_request(process_id, secret_key, buf)), } => {
cancel_request(process_id, secret_key, buf);
Ok(())
}
Message::Close { variant, name } => close(variant, name, buf), Message::Close { variant, name } => close(variant, name, buf),
Message::CopyData { data } => copy_data(data, buf), Message::CopyData { data } => copy_data(data, buf),
Message::CopyDone => Ok(copy_done(buf)), Message::CopyDone => {
copy_done(buf);
Ok(())
}
Message::CopyFail { message } => copy_fail(message, buf), Message::CopyFail { message } => copy_fail(message, buf),
Message::Describe { variant, name } => describe(variant, name, buf), Message::Describe { variant, name } => describe(variant, name, buf),
Message::Execute { portal, max_rows } => execute(portal, max_rows, buf), Message::Execute { portal, max_rows } => execute(portal, max_rows, buf),
@ -120,12 +126,21 @@ impl<'a> Message<'a> {
sasl_initial_response(mechanism, data, buf) sasl_initial_response(mechanism, data, buf)
} }
Message::SaslResponse { data } => sasl_response(data, buf), Message::SaslResponse { data } => sasl_response(data, buf),
Message::SslRequest => Ok(ssl_request(buf)), Message::SslRequest => {
ssl_request(buf);
Ok(())
}
Message::StartupMessage { parameters } => { Message::StartupMessage { parameters } => {
startup_message(parameters.iter().map(|&(ref k, ref v)| (&**k, &**v)), buf) startup_message(parameters.iter().map(|&(ref k, ref v)| (&**k, &**v)), buf)
} }
Message::Sync => Ok(sync(buf)), Message::Sync => {
Message::Terminate => Ok(terminate(buf)), sync(buf);
Ok(())
}
Message::Terminate => {
terminate(buf);
Ok(())
}
Message::__ForExtensibility => unreachable!(), Message::__ForExtensibility => unreachable!(),
} }
} }
@ -222,7 +237,7 @@ where
#[inline] #[inline]
pub fn cancel_request(process_id: i32, secret_key: i32, buf: &mut Vec<u8>) { pub fn cancel_request(process_id: i32, secret_key: i32, buf: &mut Vec<u8>) {
write_body(buf, |buf| { write_body(buf, |buf| {
buf.write_i32::<BigEndian>(80877102).unwrap(); buf.write_i32::<BigEndian>(80_877_102).unwrap();
buf.write_i32::<BigEndian>(process_id).unwrap(); buf.write_i32::<BigEndian>(process_id).unwrap();
buf.write_i32::<BigEndian>(secret_key) buf.write_i32::<BigEndian>(secret_key)
}) })
@ -320,12 +335,15 @@ pub fn sasl_initial_response(mechanism: &str, data: &[u8], buf: &mut Vec<u8>) ->
#[inline] #[inline]
pub fn sasl_response(data: &[u8], buf: &mut Vec<u8>) -> io::Result<()> { pub fn sasl_response(data: &[u8], buf: &mut Vec<u8>) -> io::Result<()> {
buf.push(b'p'); buf.push(b'p');
write_body(buf, |buf| Ok(buf.extend_from_slice(data))) write_body(buf, |buf| {
buf.extend_from_slice(data);
Ok(())
})
} }
#[inline] #[inline]
pub fn ssl_request(buf: &mut Vec<u8>) { pub fn ssl_request(buf: &mut Vec<u8>) {
write_body(buf, |buf| buf.write_i32::<BigEndian>(80877103)).unwrap(); write_body(buf, |buf| buf.write_i32::<BigEndian>(80_877_103)).unwrap();
} }
#[inline] #[inline]
@ -334,10 +352,10 @@ where
I: IntoIterator<Item = (&'a str, &'a str)>, I: IntoIterator<Item = (&'a str, &'a str)>,
{ {
write_body(buf, |buf| { write_body(buf, |buf| {
buf.write_i32::<BigEndian>(196608).unwrap(); buf.write_i32::<BigEndian>(196_608).unwrap();
for (key, value) in parameters { for (key, value) in parameters {
buf.write_cstr(key.as_ref())?; buf.write_cstr(key)?;
buf.write_cstr(value.as_ref())?; buf.write_cstr(value)?;
} }
buf.push(0); buf.push(0);
Ok(()) Ok(())

44
postgres-protocol/src/types.rs
View File

@ -216,7 +216,7 @@ pub fn hstore_from_sql<'a>(
Ok(HstoreEntries { Ok(HstoreEntries {
remaining: count, remaining: count,
buf: buf, buf,
}) })
} }
@ -231,6 +231,7 @@ impl<'a> FallibleIterator for HstoreEntries<'a> {
type Error = StdBox<dyn Error + Sync + Send>; type Error = StdBox<dyn Error + Sync + Send>;
#[inline] #[inline]
#[allow(clippy::type_complexity)]
fn next( fn next(
&mut self, &mut self,
) -> Result<Option<(&'a str, Option<&'a str>)>, StdBox<dyn Error + Sync + Send>> { ) -> Result<Option<(&'a str, Option<&'a str>)>, StdBox<dyn Error + Sync + Send>> {
@ -324,6 +325,12 @@ impl<'a> Varbit<'a> {
self.len self.len
} }
/// Determines if the value has no bits.
#[inline]
pub fn is_empty(&self) -> bool {
self.len == 0
}
/// Returns the bits as a slice of bytes. /// Returns the bits as a slice of bytes.
#[inline] #[inline]
pub fn bytes(&self) -> &'a [u8] { pub fn bytes(&self) -> &'a [u8] {
@ -503,11 +510,11 @@ pub fn array_from_sql<'a>(mut buf: &'a [u8]) -> Result<Array<'a>, StdBox<dyn Err
} }
Ok(Array { Ok(Array {
dimensions: dimensions, dimensions,
has_nulls: has_nulls, has_nulls,
element_type: element_type, element_type,
elements: elements, elements,
buf: buf, buf,
}) })
} }
@ -565,10 +572,7 @@ impl<'a> FallibleIterator for ArrayDimensions<'a> {
let len = self.0.read_i32::<BigEndian>()?; let len = self.0.read_i32::<BigEndian>()?;
let lower_bound = self.0.read_i32::<BigEndian>()?; let lower_bound = self.0.read_i32::<BigEndian>()?;
Ok(Some(ArrayDimension { Ok(Some(ArrayDimension { len, lower_bound }))
len: len,
lower_bound: lower_bound,
}))
} }
#[inline] #[inline]
@ -783,7 +787,7 @@ pub fn point_from_sql(mut buf: &[u8]) -> Result<Point, StdBox<dyn Error + Sync +
if !buf.is_empty() { if !buf.is_empty() {
return Err("invalid buffer size".into()); return Err("invalid buffer size".into());
} }
Ok(Point { x: x, y: y }) Ok(Point { x, y })
} }
/// A Postgres point. /// A Postgres point.
@ -887,9 +891,9 @@ pub fn path_from_sql<'a>(mut buf: &'a [u8]) -> Result<Path<'a>, StdBox<dyn Error
let points = buf.read_i32::<BigEndian>()?; let points = buf.read_i32::<BigEndian>()?;
Ok(Path { Ok(Path {
closed: closed, closed,
points: points, points,
buf: buf, buf,
}) })
} }
@ -940,7 +944,7 @@ impl<'a> FallibleIterator for PathPoints<'a> {
let x = self.buf.read_f64::<BigEndian>()?; let x = self.buf.read_f64::<BigEndian>()?;
let y = self.buf.read_f64::<BigEndian>()?; let y = self.buf.read_f64::<BigEndian>()?;
Ok(Some(Point { x: x, y: y })) Ok(Some(Point { x, y }))
} }
#[inline] #[inline]
@ -979,18 +983,19 @@ mod test {
#[test] #[test]
fn int4() { fn int4() {
let mut buf = vec![]; let mut buf = vec![];
int4_to_sql(0x01020304, &mut buf); int4_to_sql(0x0102_0304, &mut buf);
assert_eq!(int4_from_sql(&buf).unwrap(), 0x01020304); assert_eq!(int4_from_sql(&buf).unwrap(), 0x0102_0304);
} }
#[test] #[test]
fn int8() { fn int8() {
let mut buf = vec![]; let mut buf = vec![];
int8_to_sql(0x0102030405060708, &mut buf); int8_to_sql(0x0102_0304_0506_0708, &mut buf);
assert_eq!(int8_from_sql(&buf).unwrap(), 0x0102030405060708); assert_eq!(int8_from_sql(&buf).unwrap(), 0x0102_0304_0506_0708);
} }
#[test] #[test]
#[allow(clippy::float_cmp)]
fn float4() { fn float4() {
let mut buf = vec![]; let mut buf = vec![];
float4_to_sql(10343.95, &mut buf); float4_to_sql(10343.95, &mut buf);
@ -998,6 +1003,7 @@ mod test {
} }
#[test] #[test]
#[allow(clippy::float_cmp)]
fn float8() { fn float8() {
let mut buf = vec![]; let mut buf = vec![];
float8_to_sql(10343.95, &mut buf); float8_to_sql(10343.95, &mut buf);

7
tokio-postgres-native-tls/src/lib.rs
View File

@ -1,4 +1,4 @@
#![warn(rust_2018_idioms)] #![warn(rust_2018_idioms, clippy::all)]
use futures::{try_ready, Async, Future, Poll}; use futures::{try_ready, Async, Future, Poll};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
@ -14,11 +14,6 @@ pub struct TlsConnector {
} }
impl TlsConnector { impl TlsConnector {
pub fn new(domain: &str) -> Result<TlsConnector, native_tls::Error> {
let connector = native_tls::TlsConnector::new()?;
Ok(TlsConnector::with_connector(connector, domain))
}
pub fn with_connector(connector: native_tls::TlsConnector, domain: &str) -> TlsConnector { pub fn with_connector(connector: native_tls::TlsConnector, domain: &str) -> TlsConnector {
TlsConnector { TlsConnector {
connector: tokio_tls::TlsConnector::from(connector), connector: tokio_tls::TlsConnector::from(connector),

2
tokio-postgres-openssl/src/lib.rs
View File

@ -1,4 +1,4 @@
#![warn(rust_2018_idioms)] #![warn(rust_2018_idioms, clippy::all)]
use futures::{try_ready, Async, Future, Poll}; use futures::{try_ready, Async, Future, Poll};
use openssl::hash::MessageDigest; use openssl::hash::MessageDigest;

2
tokio-postgres/Cargo.toml
View File

@ -34,7 +34,7 @@ with-serde_json-1 = ["serde-1", "serde_json-1"]
[dependencies] [dependencies]
antidote = "1.0" antidote = "1.0"
bytes = "0.4" bytes = "0.4"
fallible-iterator = "0.1.3" fallible-iterator = "0.1.6"
futures = "0.1.7" futures = "0.1.7"
futures-cpupool = "0.1" futures-cpupool = "0.1"
log = "0.4" log = "0.4"

6
tokio-postgres/src/builder.rs
View File

@ -10,6 +10,12 @@ pub struct Builder {
password: Option<String>, password: Option<String>,
} }
impl Default for Builder {
fn default() -> Builder {
Builder::new()
}
}
impl Builder { impl Builder {
pub fn new() -> Builder { pub fn new() -> Builder {
let mut params = HashMap::new(); let mut params = HashMap::new();

33
tokio-postgres/src/error/mod.rs
View File

@ -8,6 +8,7 @@ use std::io;
pub use self::sqlstate::*; pub use self::sqlstate::*;
#[allow(clippy::unreadable_literal)]
mod sqlstate; mod sqlstate;
/// The severity of a Postgres error or notice. /// The severity of a Postgres error or notice.
@ -85,7 +86,7 @@ pub struct DbError {
} }
impl DbError { impl DbError {
pub(crate) fn new(fields: &mut ErrorFields<'_>) -> io::Result<DbError> { pub(crate) fn parse(fields: &mut ErrorFields<'_>) -> io::Result<DbError> {
let mut severity = None; let mut severity = None;
let mut parsed_severity = None; let mut parsed_severity = None;
let mut code = None; let mut code = None;
@ -160,18 +161,18 @@ impl DbError {
Ok(DbError { Ok(DbError {
severity: severity severity: severity
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`S` field missing"))?, .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`S` field missing"))?,
parsed_severity: parsed_severity, parsed_severity,
code: code code: code
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`C` field missing"))?, .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`C` field missing"))?,
message: message message: message
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`M` field missing"))?, .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "`M` field missing"))?,
detail: detail, detail,
hint: hint, hint,
position: match normal_position { position: match normal_position {
Some(position) => Some(ErrorPosition::Original(position)), Some(position) => Some(ErrorPosition::Original(position)),
None => match internal_position { None => match internal_position {
Some(position) => Some(ErrorPosition::Internal { Some(position) => Some(ErrorPosition::Internal {
position: position, position,
query: internal_query.ok_or_else(|| { query: internal_query.ok_or_else(|| {
io::Error::new( io::Error::new(
io::ErrorKind::InvalidInput, io::ErrorKind::InvalidInput,
@ -182,15 +183,15 @@ impl DbError {
None => None, None => None,
}, },
}, },
where_: where_, where_,
schema: schema, schema,
table: table, table,
column: column, column,
datatype: datatype, datatype,
constraint: constraint, constraint,
file: file, file,
line: line, line,
routine: routine, routine,
}) })
} }
@ -423,8 +424,9 @@ impl Error {
Error::new(Kind::UnexpectedMessage, None) Error::new(Kind::UnexpectedMessage, None)
} }
#[allow(clippy::needless_pass_by_value)]
pub(crate) fn db(error: ErrorResponseBody) -> Error { pub(crate) fn db(error: ErrorResponseBody) -> Error {
match DbError::new(&mut error.fields()) { match DbError::parse(&mut error.fields()) {
Ok(e) => Error::new(Kind::Db, Some(Box::new(e))), Ok(e) => Error::new(Kind::Db, Some(Box::new(e))),
Err(e) => Error::new(Kind::Parse, Some(Box::new(e))), Err(e) => Error::new(Kind::Parse, Some(Box::new(e))),
} }
@ -438,6 +440,7 @@ impl Error {
Error::new(Kind::Encode, Some(Box::new(e))) Error::new(Kind::Encode, Some(Box::new(e)))
} }
#[allow(clippy::wrong_self_convention)]
pub(crate) fn to_sql(e: Box<dyn error::Error + Sync + Send>) -> Error { pub(crate) fn to_sql(e: Box<dyn error::Error + Sync + Send>) -> Error {
Error::new(Kind::ToSql, Some(e)) Error::new(Kind::ToSql, Some(e))
} }

606
tokio-postgres/src/error/sqlstate.rs
View File

@ -1,5 +1,4 @@
// Autogenerated file - DO NOT EDIT // Autogenerated file - DO NOT EDIT
use phf;
use std::borrow::Cow; use std::borrow::Cow;
/// A SQLSTATE error code /// A SQLSTATE error code
@ -33,8 +32,7 @@ impl SqlState {
pub const WARNING_IMPLICIT_ZERO_BIT_PADDING: SqlState = SqlState(Cow::Borrowed("01008")); pub const WARNING_IMPLICIT_ZERO_BIT_PADDING: SqlState = SqlState(Cow::Borrowed("01008"));
/// 01003 /// 01003
pub const WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION: SqlState = pub const WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION: SqlState = SqlState(Cow::Borrowed("01003"));
SqlState(Cow::Borrowed("01003"));
/// 01007 /// 01007
pub const WARNING_PRIVILEGE_NOT_GRANTED: SqlState = SqlState(Cow::Borrowed("01007")); pub const WARNING_PRIVILEGE_NOT_GRANTED: SqlState = SqlState(Cow::Borrowed("01007"));
@ -52,8 +50,7 @@ impl SqlState {
pub const NO_DATA: SqlState = SqlState(Cow::Borrowed("02000")); pub const NO_DATA: SqlState = SqlState(Cow::Borrowed("02000"));
/// 02001 /// 02001
pub const NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED: SqlState = pub const NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED: SqlState = SqlState(Cow::Borrowed("02001"));
SqlState(Cow::Borrowed("02001"));
/// 03000 /// 03000
pub const SQL_STATEMENT_NOT_YET_COMPLETE: SqlState = SqlState(Cow::Borrowed("03000")); pub const SQL_STATEMENT_NOT_YET_COMPLETE: SqlState = SqlState(Cow::Borrowed("03000"));
@ -68,12 +65,10 @@ impl SqlState {
pub const CONNECTION_FAILURE: SqlState = SqlState(Cow::Borrowed("08006")); pub const CONNECTION_FAILURE: SqlState = SqlState(Cow::Borrowed("08006"));
/// 08001 /// 08001
pub const SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION: SqlState = pub const SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION: SqlState = SqlState(Cow::Borrowed("08001"));
SqlState(Cow::Borrowed("08001"));
/// 08004 /// 08004
pub const SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION: SqlState = pub const SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION: SqlState = SqlState(Cow::Borrowed("08004"));
SqlState(Cow::Borrowed("08004"));
/// 08007 /// 08007
pub const TRANSACTION_RESOLUTION_UNKNOWN: SqlState = SqlState(Cow::Borrowed("08007")); pub const TRANSACTION_RESOLUTION_UNKNOWN: SqlState = SqlState(Cow::Borrowed("08007"));
@ -109,8 +104,7 @@ impl SqlState {
pub const DIAGNOSTICS_EXCEPTION: SqlState = SqlState(Cow::Borrowed("0Z000")); pub const DIAGNOSTICS_EXCEPTION: SqlState = SqlState(Cow::Borrowed("0Z000"));
/// 0Z002 /// 0Z002
pub const STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER: SqlState = pub const STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER: SqlState = SqlState(Cow::Borrowed("0Z002"));
SqlState(Cow::Borrowed("0Z002"));
/// 20000 /// 20000
pub const CASE_NOT_FOUND: SqlState = SqlState(Cow::Borrowed("20000")); pub const CASE_NOT_FOUND: SqlState = SqlState(Cow::Borrowed("20000"));
@ -164,8 +158,7 @@ impl SqlState {
pub const INVALID_ARGUMENT_FOR_POWER_FUNCTION: SqlState = SqlState(Cow::Borrowed("2201F")); pub const INVALID_ARGUMENT_FOR_POWER_FUNCTION: SqlState = SqlState(Cow::Borrowed("2201F"));
/// 2201G /// 2201G
pub const INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION: SqlState = pub const INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION: SqlState = SqlState(Cow::Borrowed("2201G"));
SqlState(Cow::Borrowed("2201G"));
/// 22018 /// 22018
pub const INVALID_CHARACTER_VALUE_FOR_CAST: SqlState = SqlState(Cow::Borrowed("22018")); pub const INVALID_CHARACTER_VALUE_FOR_CAST: SqlState = SqlState(Cow::Borrowed("22018"));
@ -198,8 +191,7 @@ impl SqlState {
pub const INVALID_ROW_COUNT_IN_LIMIT_CLAUSE: SqlState = SqlState(Cow::Borrowed("2201W")); pub const INVALID_ROW_COUNT_IN_LIMIT_CLAUSE: SqlState = SqlState(Cow::Borrowed("2201W"));
/// 2201X /// 2201X
pub const INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE: SqlState = pub const INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE: SqlState = SqlState(Cow::Borrowed("2201X"));
SqlState(Cow::Borrowed("2201X"));
/// 2202H /// 2202H
pub const INVALID_TABLESAMPLE_ARGUMENT: SqlState = SqlState(Cow::Borrowed("2202H")); pub const INVALID_TABLESAMPLE_ARGUMENT: SqlState = SqlState(Cow::Borrowed("2202H"));
@ -310,27 +302,22 @@ impl SqlState {
pub const BRANCH_TRANSACTION_ALREADY_ACTIVE: SqlState = SqlState(Cow::Borrowed("25002")); pub const BRANCH_TRANSACTION_ALREADY_ACTIVE: SqlState = SqlState(Cow::Borrowed("25002"));
/// 25008 /// 25008
pub const HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL: SqlState = pub const HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL: SqlState = SqlState(Cow::Borrowed("25008"));
SqlState(Cow::Borrowed("25008"));
/// 25003 /// 25003
pub const INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION: SqlState = pub const INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25003"));
SqlState(Cow::Borrowed("25003"));
/// 25004 /// 25004
pub const INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION: SqlState = pub const INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25004"));
SqlState(Cow::Borrowed("25004"));
/// 25005 /// 25005
pub const NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION: SqlState = pub const NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25005"));
SqlState(Cow::Borrowed("25005"));
/// 25006 /// 25006
pub const READ_ONLY_SQL_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25006")); pub const READ_ONLY_SQL_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25006"));
/// 25007 /// 25007
pub const SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED: SqlState = pub const SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED: SqlState = SqlState(Cow::Borrowed("25007"));
SqlState(Cow::Borrowed("25007"));
/// 25P01 /// 25P01
pub const NO_ACTIVE_SQL_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25P01")); pub const NO_ACTIVE_SQL_TRANSACTION: SqlState = SqlState(Cow::Borrowed("25P01"));
@ -357,8 +344,7 @@ impl SqlState {
pub const INVALID_PASSWORD: SqlState = SqlState(Cow::Borrowed("28P01")); pub const INVALID_PASSWORD: SqlState = SqlState(Cow::Borrowed("28P01"));
/// 2B000 /// 2B000
pub const DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST: SqlState = pub const DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST: SqlState = SqlState(Cow::Borrowed("2B000"));
SqlState(Cow::Borrowed("2B000"));
/// 2BP01 /// 2BP01
pub const DEPENDENT_OBJECTS_STILL_EXIST: SqlState = SqlState(Cow::Borrowed("2BP01")); pub const DEPENDENT_OBJECTS_STILL_EXIST: SqlState = SqlState(Cow::Borrowed("2BP01"));
@ -370,8 +356,7 @@ impl SqlState {
pub const SQL_ROUTINE_EXCEPTION: SqlState = SqlState(Cow::Borrowed("2F000")); pub const SQL_ROUTINE_EXCEPTION: SqlState = SqlState(Cow::Borrowed("2F000"));
/// 2F005 /// 2F005
pub const S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT: SqlState = pub const S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT: SqlState = SqlState(Cow::Borrowed("2F005"));
SqlState(Cow::Borrowed("2F005"));
/// 2F002 /// 2F002
pub const S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED: SqlState = SqlState(Cow::Borrowed("2F002")); pub const S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED: SqlState = SqlState(Cow::Borrowed("2F002"));
@ -713,8 +698,7 @@ impl SqlState {
pub const FDW_INVALID_OPTION_NAME: SqlState = SqlState(Cow::Borrowed("HV00D")); pub const FDW_INVALID_OPTION_NAME: SqlState = SqlState(Cow::Borrowed("HV00D"));
/// HV090 /// HV090
pub const FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH: SqlState = pub const FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH: SqlState = SqlState(Cow::Borrowed("HV090"));
SqlState(Cow::Borrowed("HV090"));
/// HV00A /// HV00A
pub const FDW_INVALID_STRING_FORMAT: SqlState = SqlState(Cow::Borrowed("HV00A")); pub const FDW_INVALID_STRING_FORMAT: SqlState = SqlState(Cow::Borrowed("HV00A"));
@ -778,299 +762,299 @@ impl SqlState {
} }
#[cfg_attr(rustfmt, rustfmt_skip)] #[cfg_attr(rustfmt, rustfmt_skip)]
static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map { static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map {
key: 1897749892740154578, key: 6246114685207409605,
disps: ::phf::Slice::Static(&[ disps: ::phf::Slice::Static(&[
(1, 99), (1, 77),
(0, 0), (0, 21),
(1, 5), (0, 6),
(0, 3),
(0, 110),
(0, 54),
(0, 3),
(0, 13), (0, 13),
(0, 0), (0, 28),
(0, 24), (0, 30),
(0, 214), (0, 1),
(0, 52), (0, 47),
(1, 34),
(0, 33),
(0, 44),
(0, 130),
(0, 16),
(0, 187),
(0, 3),
(13, 168),
(0, 4),
(0, 19),
(0, 13),
(0, 87),
(0, 0),
(0, 108),
(0, 123),
(7, 181),
(0, 109),
(0, 32),
(0, 0),
(1, 69),
(1, 81),
(1, 219),
(0, 157),
(2, 41),
(8, 141),
(0, 5), (0, 5),
(0, 5),
(0, 52),
(0, 96),
(0, 66),
(3, 167),
(0, 10),
(0, 56),
(2, 159),
(0, 28),
(0, 11),
(0, 6),
(0, 0), (0, 0),
(1, 188),
(7, 122),
(2, 32),
(1, 6), (1, 6),
(0, 3), (1, 142),
(1, 146), (1, 0),
(1, 227), (1, 71),
(9, 94), (2, 35),
(10, 158), (0, 1),
(29, 65), (0, 68),
(3, 2), (0, 66),
(0, 33), (5, 43),
(1, 94), (0, 0),
(1, 0),
(2, 123),
(1, 1),
(0, 31),
(3, 7),
(3, 172),
(0, 35),
(0, 107),
(0, 106),
(0, 102),
(17, 207),
(6, 8),
(0, 105),
(26, 87),
(0, 21),
]), ]),
entries: ::phf::Slice::Static(&[ entries: ::phf::Slice::Static(&[
("23001", SqlState::RESTRICT_VIOLATION),
("42830", SqlState::INVALID_FOREIGN_KEY),
("P0000", SqlState::PLPGSQL_ERROR),
("58000", SqlState::SYSTEM_ERROR),
("57P01", SqlState::ADMIN_SHUTDOWN),
("22P04", SqlState::BAD_COPY_FILE_FORMAT),
("42P05", SqlState::DUPLICATE_PSTATEMENT),
("28000", SqlState::INVALID_AUTHORIZATION_SPECIFICATION),
("2202E", SqlState::ARRAY_ELEMENT_ERROR),
("2F005", SqlState::S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
("53400", SqlState::CONFIGURATION_LIMIT_EXCEEDED),
("20000", SqlState::CASE_NOT_FOUND),
("25004", SqlState::INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION),
("09000", SqlState::TRIGGERED_ACTION_EXCEPTION),
("42P10", SqlState::INVALID_COLUMN_REFERENCE),
("39P03", SqlState::E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
("08000", SqlState::CONNECTION_EXCEPTION),
("08006", SqlState::CONNECTION_FAILURE),
("2201W", SqlState::INVALID_ROW_COUNT_IN_LIMIT_CLAUSE),
("03000", SqlState::SQL_STATEMENT_NOT_YET_COMPLETE),
("22014", SqlState::INVALID_ARGUMENT_FOR_NTILE),
("42611", SqlState::INVALID_COLUMN_DEFINITION),
("42P11", SqlState::INVALID_CURSOR_DEFINITION),
("2200N", SqlState::INVALID_XML_CONTENT),
("57014", SqlState::QUERY_CANCELED),
("01003", SqlState::WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION),
("01000", SqlState::WARNING),
("55P04", SqlState::UNSAFE_NEW_ENUM_VALUE_USAGE),
("25003", SqlState::INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION),
("2200L", SqlState::NOT_AN_XML_DOCUMENT),
("42846", SqlState::CANNOT_COERCE),
("55P03", SqlState::LOCK_NOT_AVAILABLE),
("08007", SqlState::TRANSACTION_RESOLUTION_UNKNOWN),
("XX000", SqlState::INTERNAL_ERROR),
("22005", SqlState::ERROR_IN_ASSIGNMENT),
("22P03", SqlState::INVALID_BINARY_REPRESENTATION),
("2201X", SqlState::INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE),
("54011", SqlState::TOO_MANY_COLUMNS),
("HV008", SqlState::FDW_INVALID_COLUMN_NUMBER),
("HV009", SqlState::FDW_INVALID_USE_OF_NULL_POINTER),
("0LP01", SqlState::INVALID_GRANT_OPERATION),
("42704", SqlState::UNDEFINED_OBJECT),
("25005", SqlState::NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION),
("25P03", SqlState::IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
("44000", SqlState::WITH_CHECK_OPTION_VIOLATION),
("22024", SqlState::UNTERMINATED_C_STRING),
("0L000", SqlState::INVALID_GRANTOR),
("40000", SqlState::TRANSACTION_ROLLBACK),
("42P08", SqlState::AMBIGUOUS_PARAMETER),
("38000", SqlState::EXTERNAL_ROUTINE_EXCEPTION),
("42939", SqlState::RESERVED_NAME),
("40001", SqlState::T_R_SERIALIZATION_FAILURE),
("HV00K", SqlState::FDW_REPLY_HANDLE),
("2F002", SqlState::S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED),
("HV001", SqlState::FDW_OUT_OF_MEMORY),
("42P19", SqlState::INVALID_RECURSION),
("HV002", SqlState::FDW_DYNAMIC_PARAMETER_VALUE_NEEDED),
("0A000", SqlState::FEATURE_NOT_SUPPORTED),
("58P02", SqlState::DUPLICATE_FILE),
("25006", SqlState::READ_ONLY_SQL_TRANSACTION),
("22009", SqlState::INVALID_TIME_ZONE_DISPLACEMENT_VALUE),
("0F001", SqlState::L_E_INVALID_SPECIFICATION),
("P0002", SqlState::NO_DATA_FOUND),
("2F000", SqlState::SQL_ROUTINE_EXCEPTION),
("01006", SqlState::WARNING_PRIVILEGE_NOT_REVOKED),
("22025", SqlState::INVALID_ESCAPE_SEQUENCE),
("22027", SqlState::TRIM_ERROR),
("54001", SqlState::STATEMENT_TOO_COMPLEX),
("42602", SqlState::INVALID_NAME),
("54023", SqlState::TOO_MANY_ARGUMENTS),
("2200T", SqlState::INVALID_XML_PROCESSING_INSTRUCTION),
("01007", SqlState::WARNING_PRIVILEGE_NOT_GRANTED),
("22000", SqlState::DATA_EXCEPTION),
("28P01", SqlState::INVALID_PASSWORD),
("23514", SqlState::CHECK_VIOLATION),
("39P02", SqlState::E_R_I_E_SRF_PROTOCOL_VIOLATED),
("57P02", SqlState::CRASH_SHUTDOWN),
("42P03", SqlState::DUPLICATE_CURSOR),
("22021", SqlState::CHARACTER_NOT_IN_REPERTOIRE),
("HV00P", SqlState::FDW_NO_SCHEMAS),
("42701", SqlState::DUPLICATE_COLUMN),
("42P15", SqlState::INVALID_SCHEMA_DEFINITION),
("HV00B", SqlState::FDW_INVALID_HANDLE),
("34000", SqlState::INVALID_CURSOR_NAME),
("22P06", SqlState::NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
("P0001", SqlState::RAISE_EXCEPTION),
("08P01", SqlState::PROTOCOL_VIOLATION),
("42723", SqlState::DUPLICATE_FUNCTION),
("08001", SqlState::SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
("HV006", SqlState::FDW_INVALID_DATA_TYPE_DESCRIPTORS),
("23000", SqlState::INTEGRITY_CONSTRAINT_VIOLATION),
("42712", SqlState::DUPLICATE_ALIAS),
("2201G", SqlState::INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
("2200F", SqlState::ZERO_LENGTH_CHARACTER_STRING),
("XX002", SqlState::INDEX_CORRUPTED),
("53300", SqlState::TOO_MANY_CONNECTIONS),
("38002", SqlState::E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED),
("22015", SqlState::INTERVAL_FIELD_OVERFLOW),
("22P01", SqlState::FLOATING_POINT_EXCEPTION),
("22012", SqlState::DIVISION_BY_ZERO),
("XX001", SqlState::DATA_CORRUPTED),
("0100C", SqlState::WARNING_DYNAMIC_RESULT_SETS_RETURNED),
("42P01", SqlState::UNDEFINED_TABLE),
("25002", SqlState::BRANCH_TRANSACTION_ALREADY_ACTIVE),
("2D000", SqlState::INVALID_TRANSACTION_TERMINATION),
("P0004", SqlState::ASSERT_FAILURE),
("2200C", SqlState::INVALID_USE_OF_ESCAPE_CHARACTER),
("HV00R", SqlState::FDW_TABLE_NOT_FOUND),
("22016", SqlState::INVALID_ARGUMENT_FOR_NTH_VALUE),
("01P01", SqlState::WARNING_DEPRECATED_FEATURE),
("F0000", SqlState::CONFIG_FILE_ERROR),
("0Z000", SqlState::DIAGNOSTICS_EXCEPTION),
("42P02", SqlState::UNDEFINED_PARAMETER),
("2200S", SqlState::INVALID_XML_COMMENT),
("2200H", SqlState::SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
("HV00C", SqlState::FDW_INVALID_OPTION_INDEX),
("38004", SqlState::E_R_E_READING_SQL_DATA_NOT_PERMITTED),
("42703", SqlState::UNDEFINED_COLUMN),
("23503", SqlState::FOREIGN_KEY_VIOLATION),
("42000", SqlState::SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION),
("22004", SqlState::NULL_VALUE_NOT_ALLOWED),
("25008", SqlState::HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL),
("22018", SqlState::INVALID_CHARACTER_VALUE_FOR_CAST),
("22023", SqlState::INVALID_PARAMETER_VALUE),
("22011", SqlState::SUBSTRING_ERROR),
("40002", SqlState::T_R_INTEGRITY_CONSTRAINT_VIOLATION),
("42803", SqlState::GROUPING_ERROR),
("72000", SqlState::SNAPSHOT_TOO_OLD),
("HV010", SqlState::FDW_FUNCTION_SEQUENCE_ERROR),
("42809", SqlState::WRONG_OBJECT_TYPE),
("42P16", SqlState::INVALID_TABLE_DEFINITION), ("42P16", SqlState::INVALID_TABLE_DEFINITION),
("HV00D", SqlState::FDW_INVALID_OPTION_NAME),
("39000", SqlState::EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
("2202G", SqlState::INVALID_TABLESAMPLE_REPEAT),
("42601", SqlState::SYNTAX_ERROR),
("42622", SqlState::NAME_TOO_LONG),
("HV00L", SqlState::FDW_UNABLE_TO_CREATE_EXECUTION),
("25000", SqlState::INVALID_TRANSACTION_STATE),
("3B000", SqlState::SAVEPOINT_EXCEPTION),
("42P21", SqlState::COLLATION_MISMATCH),
("23505", SqlState::UNIQUE_VIOLATION),
("22001", SqlState::STRING_DATA_RIGHT_TRUNCATION),
("02001", SqlState::NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED),
("21000", SqlState::CARDINALITY_VIOLATION),
("58P01", SqlState::UNDEFINED_FILE),
("HV091", SqlState::FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER),
("25P01", SqlState::NO_ACTIVE_SQL_TRANSACTION),
("40P01", SqlState::T_R_DEADLOCK_DETECTED),
("HV021", SqlState::FDW_INCONSISTENT_DESCRIPTOR_INFORMATION),
("42P09", SqlState::AMBIGUOUS_ALIAS),
("25007", SqlState::SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED),
("23P01", SqlState::EXCLUSION_VIOLATION),
("HV00J", SqlState::FDW_OPTION_NAME_NOT_FOUND),
("58030", SqlState::IO_ERROR),
("HV004", SqlState::FDW_INVALID_DATA_TYPE),
("42710", SqlState::DUPLICATE_OBJECT),
("HV090", SqlState::FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH),
("42P18", SqlState::INDETERMINATE_DATATYPE),
("HV00M", SqlState::FDW_UNABLE_TO_CREATE_REPLY),
("42804", SqlState::DATATYPE_MISMATCH),
("24000", SqlState::INVALID_CURSOR_STATE),
("HV007", SqlState::FDW_INVALID_COLUMN_NAME),
("2201E", SqlState::INVALID_ARGUMENT_FOR_LOG),
("42P22", SqlState::INDETERMINATE_COLLATION),
("22P05", SqlState::UNTRANSLATABLE_CHARACTER),
("42P07", SqlState::DUPLICATE_TABLE),
("2F004", SqlState::S_R_E_READING_SQL_DATA_NOT_PERMITTED),
("23502", SqlState::NOT_NULL_VIOLATION),
("57000", SqlState::OPERATOR_INTERVENTION),
("HV000", SqlState::FDW_ERROR),
("42883", SqlState::UNDEFINED_FUNCTION),
("2201B", SqlState::INVALID_REGULAR_EXPRESSION),
("2200D", SqlState::INVALID_ESCAPE_OCTET),
("42P06", SqlState::DUPLICATE_SCHEMA),
("38003", SqlState::E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
("22026", SqlState::STRING_DATA_LENGTH_MISMATCH),
("P0003", SqlState::TOO_MANY_ROWS),
("3D000", SqlState::INVALID_CATALOG_NAME),
("0B000", SqlState::INVALID_TRANSACTION_INITIATION),
("55006", SqlState::OBJECT_IN_USE),
("53200", SqlState::OUT_OF_MEMORY),
("3F000", SqlState::INVALID_SCHEMA_NAME),
("53100", SqlState::DISK_FULL),
("2F003", SqlState::S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
("55P02", SqlState::CANT_CHANGE_RUNTIME_PARAM),
("01004", SqlState::WARNING_STRING_DATA_RIGHT_TRUNCATION),
("3B001", SqlState::S_E_INVALID_SPECIFICATION),
("2200G", SqlState::MOST_SPECIFIC_TYPE_MISMATCH),
("428C9", SqlState::GENERATED_ALWAYS), ("428C9", SqlState::GENERATED_ALWAYS),
("HV005", SqlState::FDW_COLUMN_NAME_NOT_FOUND), ("22015", SqlState::INTERVAL_FIELD_OVERFLOW),
("2201F", SqlState::INVALID_ARGUMENT_FOR_POWER_FUNCTION), ("42622", SqlState::NAME_TOO_LONG),
("22022", SqlState::INDICATOR_OVERFLOW), ("42804", SqlState::DATATYPE_MISMATCH),
("HV00Q", SqlState::FDW_SCHEMA_NOT_FOUND),
("0F000", SqlState::LOCATOR_EXCEPTION),
("22002", SqlState::NULL_VALUE_NO_INDICATOR_PARAMETER),
("02000", SqlState::NO_DATA),
("2202H", SqlState::INVALID_TABLESAMPLE_ARGUMENT),
("27000", SqlState::TRIGGERED_DATA_CHANGE_VIOLATION),
("2BP01", SqlState::DEPENDENT_OBJECTS_STILL_EXIST),
("55000", SqlState::OBJECT_NOT_IN_PREREQUISITE_STATE),
("39001", SqlState::E_R_I_E_INVALID_SQLSTATE_RETURNED),
("08004", SqlState::SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION),
("42P13", SqlState::INVALID_FUNCTION_DEFINITION),
("HV024", SqlState::FDW_INVALID_ATTRIBUTE_VALUE),
("22019", SqlState::INVALID_ESCAPE_CHARACTER),
("54000", SqlState::PROGRAM_LIMIT_EXCEEDED),
("42501", SqlState::INSUFFICIENT_PRIVILEGE),
("HV00A", SqlState::FDW_INVALID_STRING_FORMAT),
("42702", SqlState::AMBIGUOUS_COLUMN),
("53000", SqlState::INSUFFICIENT_RESOURCES),
("25P02", SqlState::IN_FAILED_SQL_TRANSACTION),
("22010", SqlState::INVALID_INDICATOR_PARAMETER_VALUE),
("01008", SqlState::WARNING_IMPLICIT_ZERO_BIT_PADDING),
("HV014", SqlState::FDW_TOO_MANY_HANDLES),
("42P20", SqlState::WINDOWING_ERROR),
("42725", SqlState::AMBIGUOUS_FUNCTION),
("F0001", SqlState::LOCK_FILE_EXISTS),
("08003", SqlState::CONNECTION_DOES_NOT_EXIST),
("2200M", SqlState::INVALID_XML_DOCUMENT),
("22003", SqlState::NUMERIC_VALUE_OUT_OF_RANGE), ("22003", SqlState::NUMERIC_VALUE_OUT_OF_RANGE),
("39004", SqlState::E_R_I_E_NULL_VALUE_NOT_ALLOWED), ("22000", SqlState::DATA_EXCEPTION),
("2200B", SqlState::ESCAPE_CHARACTER_CONFLICT), ("22004", SqlState::NULL_VALUE_NOT_ALLOWED),
("0P000", SqlState::INVALID_ROLE_SPECIFICATION), ("22P05", SqlState::UNTRANSLATABLE_CHARACTER),
("00000", SqlState::SUCCESSFUL_COMPLETION), ("22016", SqlState::INVALID_ARGUMENT_FOR_NTH_VALUE),
("22P02", SqlState::INVALID_TEXT_REPRESENTATION), ("2201B", SqlState::INVALID_REGULAR_EXPRESSION),
("25001", SqlState::ACTIVE_SQL_TRANSACTION), ("HV001", SqlState::FDW_OUT_OF_MEMORY),
("HV00N", SqlState::FDW_UNABLE_TO_ESTABLISH_CONNECTION), ("42704", SqlState::UNDEFINED_OBJECT),
("39P01", SqlState::E_R_I_E_TRIGGER_PROTOCOL_VIOLATED), ("42703", SqlState::UNDEFINED_COLUMN),
("2B000", SqlState::DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST), ("53300", SqlState::TOO_MANY_CONNECTIONS),
("23505", SqlState::UNIQUE_VIOLATION),
("42712", SqlState::DUPLICATE_ALIAS),
("22008", SqlState::DATETIME_FIELD_OVERFLOW), ("22008", SqlState::DATETIME_FIELD_OVERFLOW),
("42P14", SqlState::INVALID_PSTATEMENT_DEFINITION), ("HV024", SqlState::FDW_INVALID_ATTRIBUTE_VALUE),
("57P04", SqlState::DATABASE_DROPPED),
("26000", SqlState::INVALID_SQL_STATEMENT_NAME), ("26000", SqlState::INVALID_SQL_STATEMENT_NAME),
("42P17", SqlState::INVALID_OBJECT_DEFINITION), ("20000", SqlState::CASE_NOT_FOUND),
("42P04", SqlState::DUPLICATE_DATABASE), ("2200L", SqlState::NOT_AN_XML_DOCUMENT),
("38001", SqlState::E_R_E_CONTAINING_SQL_NOT_PERMITTED), ("42939", SqlState::RESERVED_NAME),
("0Z002", SqlState::STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER),
("22007", SqlState::INVALID_DATETIME_FORMAT),
("40003", SqlState::T_R_STATEMENT_COMPLETION_UNKNOWN),
("42P12", SqlState::INVALID_DATABASE_DEFINITION), ("42P12", SqlState::INVALID_DATABASE_DEFINITION),
("42P20", SqlState::WINDOWING_ERROR),
("25003", SqlState::INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION),
("42P09", SqlState::AMBIGUOUS_ALIAS),
("HV00B", SqlState::FDW_INVALID_HANDLE),
("54011", SqlState::TOO_MANY_COLUMNS),
("42725", SqlState::AMBIGUOUS_FUNCTION),
("25002", SqlState::BRANCH_TRANSACTION_ALREADY_ACTIVE),
("42701", SqlState::DUPLICATE_COLUMN),
("HV009", SqlState::FDW_INVALID_USE_OF_NULL_POINTER),
("38003", SqlState::E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
("0P000", SqlState::INVALID_ROLE_SPECIFICATION),
("39004", SqlState::E_R_I_E_NULL_VALUE_NOT_ALLOWED),
("HV002", SqlState::FDW_DYNAMIC_PARAMETER_VALUE_NEEDED),
("39P01", SqlState::E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
("08003", SqlState::CONNECTION_DOES_NOT_EXIST),
("22022", SqlState::INDICATOR_OVERFLOW),
("02001", SqlState::NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED),
("01008", SqlState::WARNING_IMPLICIT_ZERO_BIT_PADDING),
("54000", SqlState::PROGRAM_LIMIT_EXCEEDED),
("22019", SqlState::INVALID_ESCAPE_CHARACTER),
("42P19", SqlState::INVALID_RECURSION),
("XX000", SqlState::INTERNAL_ERROR),
("HV00K", SqlState::FDW_REPLY_HANDLE),
("25005", SqlState::NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION),
("HV004", SqlState::FDW_INVALID_DATA_TYPE),
("24000", SqlState::INVALID_CURSOR_STATE),
("42P11", SqlState::INVALID_CURSOR_DEFINITION),
("0100C", SqlState::WARNING_DYNAMIC_RESULT_SETS_RETURNED),
("HV014", SqlState::FDW_TOO_MANY_HANDLES),
("0Z000", SqlState::DIAGNOSTICS_EXCEPTION),
("57P04", SqlState::DATABASE_DROPPED),
("38002", SqlState::E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED),
("HV00Q", SqlState::FDW_SCHEMA_NOT_FOUND),
("22P06", SqlState::NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
("22011", SqlState::SUBSTRING_ERROR),
("42P21", SqlState::COLLATION_MISMATCH),
("0F001", SqlState::L_E_INVALID_SPECIFICATION),
("23502", SqlState::NOT_NULL_VIOLATION),
("HV00M", SqlState::FDW_UNABLE_TO_CREATE_REPLY),
("0L000", SqlState::INVALID_GRANTOR),
("42809", SqlState::WRONG_OBJECT_TYPE),
("23503", SqlState::FOREIGN_KEY_VIOLATION),
("HV021", SqlState::FDW_INCONSISTENT_DESCRIPTOR_INFORMATION),
("25001", SqlState::ACTIVE_SQL_TRANSACTION),
("44000", SqlState::WITH_CHECK_OPTION_VIOLATION),
("42P03", SqlState::DUPLICATE_CURSOR),
("P0004", SqlState::ASSERT_FAILURE),
("P0003", SqlState::TOO_MANY_ROWS),
("2F002", SqlState::S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED),
("40003", SqlState::T_R_STATEMENT_COMPLETION_UNKNOWN),
("22014", SqlState::INVALID_ARGUMENT_FOR_NTILE),
("22010", SqlState::INVALID_INDICATOR_PARAMETER_VALUE),
("40000", SqlState::TRANSACTION_ROLLBACK),
("2201G", SqlState::INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
("42000", SqlState::SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION),
("55P03", SqlState::LOCK_NOT_AVAILABLE),
("57000", SqlState::OPERATOR_INTERVENTION),
("42P10", SqlState::INVALID_COLUMN_REFERENCE),
("HV008", SqlState::FDW_INVALID_COLUMN_NUMBER),
("22021", SqlState::CHARACTER_NOT_IN_REPERTOIRE),
("0Z002", SqlState::STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER),
("39000", SqlState::EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
("28000", SqlState::INVALID_AUTHORIZATION_SPECIFICATION),
("42710", SqlState::DUPLICATE_OBJECT),
("03000", SqlState::SQL_STATEMENT_NOT_YET_COMPLETE),
("54023", SqlState::TOO_MANY_ARGUMENTS),
("72000", SqlState::SNAPSHOT_TOO_OLD),
("HV00P", SqlState::FDW_NO_SCHEMAS),
("38001", SqlState::E_R_E_CONTAINING_SQL_NOT_PERMITTED),
("2200G", SqlState::MOST_SPECIFIC_TYPE_MISMATCH),
("2201E", SqlState::INVALID_ARGUMENT_FOR_LOG),
("58000", SqlState::SYSTEM_ERROR),
("42P07", SqlState::DUPLICATE_TABLE),
("22025", SqlState::INVALID_ESCAPE_SEQUENCE),
("2201F", SqlState::INVALID_ARGUMENT_FOR_POWER_FUNCTION),
("42P22", SqlState::INDETERMINATE_COLLATION),
("54001", SqlState::STATEMENT_TOO_COMPLEX),
("HV091", SqlState::FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER),
("HV090", SqlState::FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH),
("25P01", SqlState::NO_ACTIVE_SQL_TRANSACTION),
("22005", SqlState::ERROR_IN_ASSIGNMENT),
("42P02", SqlState::UNDEFINED_PARAMETER),
("42P08", SqlState::AMBIGUOUS_PARAMETER),
("22023", SqlState::INVALID_PARAMETER_VALUE),
("25007", SqlState::SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED),
("08P01", SqlState::PROTOCOL_VIOLATION),
("22P01", SqlState::FLOATING_POINT_EXCEPTION),
("42P01", SqlState::UNDEFINED_TABLE),
("P0002", SqlState::NO_DATA_FOUND),
("2F005", SqlState::S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
("F0001", SqlState::LOCK_FILE_EXISTS),
("2200D", SqlState::INVALID_ESCAPE_OCTET),
("22P04", SqlState::BAD_COPY_FILE_FORMAT),
("2200B", SqlState::ESCAPE_CHARACTER_CONFLICT),
("P0000", SqlState::PLPGSQL_ERROR),
("2D000", SqlState::INVALID_TRANSACTION_TERMINATION),
("01007", SqlState::WARNING_PRIVILEGE_NOT_GRANTED),
("HV00C", SqlState::FDW_INVALID_OPTION_INDEX),
("3B000", SqlState::SAVEPOINT_EXCEPTION),
("40001", SqlState::T_R_SERIALIZATION_FAILURE),
("42P18", SqlState::INDETERMINATE_DATATYPE),
("HV00A", SqlState::FDW_INVALID_STRING_FORMAT),
("XX002", SqlState::INDEX_CORRUPTED),
("39P02", SqlState::E_R_I_E_SRF_PROTOCOL_VIOLATED),
("HV00D", SqlState::FDW_INVALID_OPTION_NAME),
("25000", SqlState::INVALID_TRANSACTION_STATE),
("0B000", SqlState::INVALID_TRANSACTION_INITIATION),
("2200T", SqlState::INVALID_XML_PROCESSING_INSTRUCTION),
("HV00J", SqlState::FDW_OPTION_NAME_NOT_FOUND),
("HV00R", SqlState::FDW_TABLE_NOT_FOUND),
("2202E", SqlState::ARRAY_ELEMENT_ERROR),
("22027", SqlState::TRIM_ERROR),
("22026", SqlState::STRING_DATA_LENGTH_MISMATCH),
("23514", SqlState::CHECK_VIOLATION),
("42702", SqlState::AMBIGUOUS_COLUMN),
("53400", SqlState::CONFIGURATION_LIMIT_EXCEEDED),
("53000", SqlState::INSUFFICIENT_RESOURCES),
("HV00N", SqlState::FDW_UNABLE_TO_ESTABLISH_CONNECTION),
("42P17", SqlState::INVALID_OBJECT_DEFINITION),
("57P01", SqlState::ADMIN_SHUTDOWN),
("55P04", SqlState::UNSAFE_NEW_ENUM_VALUE_USAGE),
("27000", SqlState::TRIGGERED_DATA_CHANGE_VIOLATION),
("2200N", SqlState::INVALID_XML_CONTENT),
("23000", SqlState::INTEGRITY_CONSTRAINT_VIOLATION),
("HV00L", SqlState::FDW_UNABLE_TO_CREATE_EXECUTION),
("22002", SqlState::NULL_VALUE_NO_INDICATOR_PARAMETER),
("58P02", SqlState::DUPLICATE_FILE),
("22018", SqlState::INVALID_CHARACTER_VALUE_FOR_CAST),
("22009", SqlState::INVALID_TIME_ZONE_DISPLACEMENT_VALUE),
("2200C", SqlState::INVALID_USE_OF_ESCAPE_CHARACTER),
("01003", SqlState::WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION),
("34000", SqlState::INVALID_CURSOR_NAME),
("F0000", SqlState::CONFIG_FILE_ERROR),
("28P01", SqlState::INVALID_PASSWORD),
("08001", SqlState::SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
("57014", SqlState::QUERY_CANCELED),
("2200M", SqlState::INVALID_XML_DOCUMENT),
("23P01", SqlState::EXCLUSION_VIOLATION),
("42602", SqlState::INVALID_NAME),
("23001", SqlState::RESTRICT_VIOLATION),
("2201X", SqlState::INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE),
("39001", SqlState::E_R_I_E_INVALID_SQLSTATE_RETURNED),
("40002", SqlState::T_R_INTEGRITY_CONSTRAINT_VIOLATION),
("22P02", SqlState::INVALID_TEXT_REPRESENTATION),
("HV000", SqlState::FDW_ERROR),
("42611", SqlState::INVALID_COLUMN_DEFINITION),
("2200H", SqlState::SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
("53200", SqlState::OUT_OF_MEMORY),
("3D000", SqlState::INVALID_CATALOG_NAME),
("08007", SqlState::TRANSACTION_RESOLUTION_UNKNOWN),
("2200S", SqlState::INVALID_XML_COMMENT),
("25006", SqlState::READ_ONLY_SQL_TRANSACTION),
("0A000", SqlState::FEATURE_NOT_SUPPORTED),
("00000", SqlState::SUCCESSFUL_COMPLETION),
("22001", SqlState::STRING_DATA_RIGHT_TRUNCATION),
("0LP01", SqlState::INVALID_GRANT_OPERATION),
("22P03", SqlState::INVALID_BINARY_REPRESENTATION),
("42P06", SqlState::DUPLICATE_SCHEMA),
("2200F", SqlState::ZERO_LENGTH_CHARACTER_STRING),
("01004", SqlState::WARNING_STRING_DATA_RIGHT_TRUNCATION),
("HV010", SqlState::FDW_FUNCTION_SEQUENCE_ERROR),
("42P05", SqlState::DUPLICATE_PSTATEMENT),
("2202H", SqlState::INVALID_TABLESAMPLE_ARGUMENT),
("P0001", SqlState::RAISE_EXCEPTION),
("58030", SqlState::IO_ERROR),
("XX001", SqlState::DATA_CORRUPTED),
("42723", SqlState::DUPLICATE_FUNCTION),
("2F004", SqlState::S_R_E_READING_SQL_DATA_NOT_PERMITTED),
("55P02", SqlState::CANT_CHANGE_RUNTIME_PARAM),
("42P14", SqlState::INVALID_PSTATEMENT_DEFINITION),
("0F000", SqlState::LOCATOR_EXCEPTION),
("42P15", SqlState::INVALID_SCHEMA_DEFINITION),
("42601", SqlState::SYNTAX_ERROR),
("39P03", SqlState::E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
("53100", SqlState::DISK_FULL),
("2F000", SqlState::SQL_ROUTINE_EXCEPTION),
("55006", SqlState::OBJECT_IN_USE),
("2BP01", SqlState::DEPENDENT_OBJECTS_STILL_EXIST),
("57P02", SqlState::CRASH_SHUTDOWN),
("21000", SqlState::CARDINALITY_VIOLATION),
("25P02", SqlState::IN_FAILED_SQL_TRANSACTION),
("55000", SqlState::OBJECT_NOT_IN_PREREQUISITE_STATE),
("42P13", SqlState::INVALID_FUNCTION_DEFINITION),
("08000", SqlState::CONNECTION_EXCEPTION),
("25008", SqlState::HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL),
("38000", SqlState::EXTERNAL_ROUTINE_EXCEPTION),
("42883", SqlState::UNDEFINED_FUNCTION),
("2201W", SqlState::INVALID_ROW_COUNT_IN_LIMIT_CLAUSE),
("25P03", SqlState::IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
("42P04", SqlState::DUPLICATE_DATABASE),
("09000", SqlState::TRIGGERED_ACTION_EXCEPTION),
("22007", SqlState::INVALID_DATETIME_FORMAT),
("HV006", SqlState::FDW_INVALID_DATA_TYPE_DESCRIPTORS),
("01006", SqlState::WARNING_PRIVILEGE_NOT_REVOKED),
("42846", SqlState::CANNOT_COERCE),
("08006", SqlState::CONNECTION_FAILURE),
("42830", SqlState::INVALID_FOREIGN_KEY),
("57P03", SqlState::CANNOT_CONNECT_NOW), ("57P03", SqlState::CANNOT_CONNECT_NOW),
("HV007", SqlState::FDW_INVALID_COLUMN_NAME),
("08004", SqlState::SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION),
("01000", SqlState::WARNING),
("2202G", SqlState::INVALID_TABLESAMPLE_REPEAT),
("02000", SqlState::NO_DATA),
("25004", SqlState::INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION),
("38004", SqlState::E_R_E_READING_SQL_DATA_NOT_PERMITTED),
("58P01", SqlState::UNDEFINED_FILE),
("22012", SqlState::DIVISION_BY_ZERO),
("01P01", SqlState::WARNING_DEPRECATED_FEATURE),
("2B000", SqlState::DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST),
("HV005", SqlState::FDW_COLUMN_NAME_NOT_FOUND),
("3B001", SqlState::S_E_INVALID_SPECIFICATION),
("42501", SqlState::INSUFFICIENT_PRIVILEGE),
("40P01", SqlState::T_R_DEADLOCK_DETECTED),
("22024", SqlState::UNTERMINATED_C_STRING),
("2F003", SqlState::S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
("42803", SqlState::GROUPING_ERROR),
("3F000", SqlState::INVALID_SCHEMA_NAME),
]), ]),
}; };

7
tokio-postgres/src/lib.rs
View File

@ -1,4 +1,4 @@
#![warn(rust_2018_idioms)] #![warn(rust_2018_idioms, clippy::all)]
use bytes::{Bytes, IntoBuf}; use bytes::{Bytes, IntoBuf};
use futures::{try_ready, Async, Future, Poll, Stream}; use futures::{try_ready, Async, Future, Poll, Stream};
@ -129,6 +129,7 @@ where
} }
} }
#[allow(clippy::large_enum_variant)]
pub enum AsyncMessage { pub enum AsyncMessage {
Notice(DbError), Notice(DbError),
Notification(Notification), Notification(Notification),
@ -308,6 +309,10 @@ impl Row {
self.0.columns() self.0.columns()
} }
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.0.len() self.0.len()
} }

4
tokio-postgres/src/proto/client.rs
View File

@ -236,8 +236,8 @@ impl Client {
); );
match r { match r {
Ok(()) => Ok(buf), Ok(()) => Ok(buf),
Err(frontend::BindError::Conversion(e)) => return Err(Error::to_sql(e)), Err(frontend::BindError::Conversion(e)) => Err(Error::to_sql(e)),
Err(frontend::BindError::Serialization(e)) => return Err(Error::encode(e)), Err(frontend::BindError::Serialization(e)) => Err(Error::encode(e)),
} }
} }

2
tokio-postgres/src/proto/connection.rs
View File

@ -103,7 +103,7 @@ where
let message = match message { let message = match message {
Message::NoticeResponse(body) => { Message::NoticeResponse(body) => {
let error = DbError::new(&mut body.fields()).map_err(Error::parse)?; let error = DbError::parse(&mut body.fields()).map_err(Error::parse)?;
return Ok(Some(AsyncMessage::Notice(error))); return Ok(Some(AsyncMessage::Notice(error)));
} }
Message::NotificationResponse(body) => { Message::NotificationResponse(body) => {

2
tokio-postgres/src/proto/prepare.rs
View File

@ -1,3 +1,5 @@
#![allow(clippy::large_enum_variant)]
use fallible_iterator::FallibleIterator; use fallible_iterator::FallibleIterator;
use futures::sync::mpsc; use futures::sync::mpsc;
use futures::{try_ready, Future, Poll, Stream}; use futures::{try_ready, Future, Poll, Stream};

2
tokio-postgres/src/proto/query.rs
View File

@ -86,7 +86,7 @@ where
} }
Some(Message::ErrorResponse(body)) => break Err(Error::db(body)), Some(Message::ErrorResponse(body)) => break Err(Error::db(body)),
Some(Message::DataRow(body)) => { Some(Message::DataRow(body)) => {
let row = Row::new(statement.statement().clone(), body)?; let row = Row::parse(statement.statement().clone(), body)?;
self.0 = State::ReadingResponse { self.0 = State::ReadingResponse {
receiver, receiver,
statement, statement,

4
tokio-postgres/src/proto/row.rs
View File

@ -12,8 +12,8 @@ pub struct Row {
} }
impl Row { impl Row {
pub fn new(statement: Statement, data: DataRowBody) -> Result<Row, Error> { pub(crate) fn parse(statement: Statement, data: DataRowBody) -> Result<Row, Error> {
let data = RowData::new(data).map_err(Error::parse)?; let data = RowData::parse(data).map_err(Error::parse)?;
Ok(Row { statement, data }) Ok(Row { statement, data })
} }

4
tokio-postgres/src/proto/transaction.rs
View File

@ -63,7 +63,7 @@ where
state: &'a mut RentToOwn<'a, Running<F, T, E>>, state: &'a mut RentToOwn<'a, Running<F, T, E>>,
) -> Poll<AfterRunning<T, E>, E> { ) -> Poll<AfterRunning<T, E>, E> {
match state.future.poll() { match state.future.poll() {
Ok(Async::NotReady) => return Ok(Async::NotReady), Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(t)) => transition!(Finishing { Ok(Async::Ready(t)) => transition!(Finishing {
future: state.client.batch_execute("COMMIT"), future: state.client.batch_execute("COMMIT"),
result: Ok(t), result: Ok(t),
@ -79,7 +79,7 @@ where
state: &'a mut RentToOwn<'a, Finishing<T, E>>, state: &'a mut RentToOwn<'a, Finishing<T, E>>,
) -> Poll<AfterFinishing<T>, E> { ) -> Poll<AfterFinishing<T>, E> {
match state.future.poll() { match state.future.poll() {
Ok(Async::NotReady) => return Ok(Async::NotReady), Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(())) => { Ok(Async::Ready(())) => {
let t = state.take().result?; let t = state.take().result?;
transition!(Finished(t)) transition!(Finished(t))

4
tokio-postgres/src/proto/typeinfo.rs
View File

@ -12,7 +12,7 @@ use crate::proto::typeinfo_composite::TypeinfoCompositeFuture;
use crate::proto::typeinfo_enum::TypeinfoEnumFuture; use crate::proto::typeinfo_enum::TypeinfoEnumFuture;
use crate::types::{Kind, Oid, Type}; use crate::types::{Kind, Oid, Type};
const TYPEINFO_QUERY: &'static str = " const TYPEINFO_QUERY: &str = "
SELECT t.typname, t.typtype, t.typelem, r.rngsubtype, t.typbasetype, n.nspname, t.typrelid SELECT t.typname, t.typtype, t.typelem, r.rngsubtype, t.typbasetype, n.nspname, t.typrelid
FROM pg_catalog.pg_type t FROM pg_catalog.pg_type t
LEFT OUTER JOIN pg_catalog.pg_range r ON r.rngtypid = t.oid LEFT OUTER JOIN pg_catalog.pg_range r ON r.rngtypid = t.oid
@ -21,7 +21,7 @@ WHERE t.oid = $1
"; ";
// Range types weren't added until Postgres 9.2, so pg_range may not exist // Range types weren't added until Postgres 9.2, so pg_range may not exist
const TYPEINFO_FALLBACK_QUERY: &'static str = " const TYPEINFO_FALLBACK_QUERY: &str = "
SELECT t.typname, t.typtype, t.typelem, NULL::OID, t.typbasetype, n.nspname, t.typrelid SELECT t.typname, t.typtype, t.typelem, NULL::OID, t.typbasetype, n.nspname, t.typrelid
FROM pg_catalog.pg_type t FROM pg_catalog.pg_type t
INNER JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid INNER JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid

2
tokio-postgres/src/proto/typeinfo_composite.rs
View File

@ -13,7 +13,7 @@ use crate::proto::statement::Statement;
use crate::proto::typeinfo::TypeinfoFuture; use crate::proto::typeinfo::TypeinfoFuture;
use crate::types::{Field, Oid}; use crate::types::{Field, Oid};
const TYPEINFO_COMPOSITE_QUERY: &'static str = " const TYPEINFO_COMPOSITE_QUERY: &str = "
SELECT attname, atttypid SELECT attname, atttypid
FROM pg_catalog.pg_attribute FROM pg_catalog.pg_attribute
WHERE attrelid = $1 WHERE attrelid = $1

4
tokio-postgres/src/proto/typeinfo_enum.rs
View File

@ -10,7 +10,7 @@ use crate::proto::query::QueryStream;
use crate::proto::statement::Statement; use crate::proto::statement::Statement;
use crate::types::Oid; use crate::types::Oid;
const TYPEINFO_ENUM_QUERY: &'static str = " const TYPEINFO_ENUM_QUERY: &str = "
SELECT enumlabel SELECT enumlabel
FROM pg_catalog.pg_enum FROM pg_catalog.pg_enum
WHERE enumtypid = $1 WHERE enumtypid = $1
@ -18,7 +18,7 @@ ORDER BY enumsortorder
"; ";
// Postgres 9.0 didn't have enumsortorder // Postgres 9.0 didn't have enumsortorder
const TYPEINFO_ENUM_FALLBACK_QUERY: &'static str = " const TYPEINFO_ENUM_FALLBACK_QUERY: &str = "
SELECT enumlabel SELECT enumlabel
FROM pg_catalog.pg_enum FROM pg_catalog.pg_enum
WHERE enumtypid = $1 WHERE enumtypid = $1

19
tokio-postgres/src/rows.rs
View File

@ -61,29 +61,18 @@ where
impl<'a, T> RowIndex for &'a T where T: ?Sized + Sealed {} impl<'a, T> RowIndex for &'a T where T: ?Sized + Sealed {}
#[doc(hidden)] pub(crate) struct RowData {
pub struct RowData {
body: DataRowBody, body: DataRowBody,
ranges: Vec<Option<Range<usize>>>, ranges: Vec<Option<Range<usize>>>,
} }
impl RowData { impl RowData {
pub fn new(body: DataRowBody) -> io::Result<RowData> { pub fn parse(body: DataRowBody) -> io::Result<RowData> {
let ranges = body.ranges().collect()?; let ranges = body.ranges().collect()?;
Ok(RowData { Ok(RowData { body, ranges })
body: body,
ranges: ranges,
})
}
pub fn len(&self) -> usize {
self.ranges.len()
} }
pub fn get(&self, index: usize) -> Option<&[u8]> { pub fn get(&self, index: usize) -> Option<&[u8]> {
match &self.ranges[index] { self.ranges[index].clone().map(|r| &self.body.buffer()[r])
&Some(ref range) => Some(&self.body.buffer()[range.clone()]),
&None => None,
}
} }
} }

5
tokio-postgres/src/stmt.rs
View File

@ -10,10 +10,7 @@ pub struct Column {
impl Column { impl Column {
#[doc(hidden)] #[doc(hidden)]
pub fn new(name: String, type_: Type) -> Column { pub fn new(name: String, type_: Type) -> Column {
Column { Column { name, type_ }
name: name,
type_: type_,
}
} }
/// Returns the name of the column. /// Returns the name of the column.

30
tokio-postgres/src/types/mod.rs
View File

@ -7,6 +7,7 @@ use std::borrow::Cow;
use std::collections::HashMap; use std::collections::HashMap;
use std::error::Error; use std::error::Error;
use std::fmt; use std::fmt;
use std::hash::BuildHasher;
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, SystemTime, UNIX_EPOCH}; use std::time::{Duration, SystemTime, UNIX_EPOCH};
@ -18,7 +19,7 @@ pub use postgres_protocol::Oid;
pub use crate::types::special::{Date, Timestamp}; pub use crate::types::special::{Date, Timestamp};
// Number of seconds from 1970-01-01 to 2000-01-01 // Number of seconds from 1970-01-01 to 2000-01-01
const TIME_SEC_CONVERSION: u64 = 946684800; const TIME_SEC_CONVERSION: u64 = 946_684_800;
const USEC_PER_SEC: u64 = 1_000_000; const USEC_PER_SEC: u64 = 1_000_000;
const NSEC_PER_USEC: u64 = 1_000; const NSEC_PER_USEC: u64 = 1_000;
@ -109,10 +110,10 @@ impl Type {
#[doc(hidden)] #[doc(hidden)]
pub fn _new(name: String, oid: Oid, kind: Kind, schema: String) -> Type { pub fn _new(name: String, oid: Oid, kind: Kind, schema: String) -> Type {
Type(Inner::Other(Arc::new(Other { Type(Inner::Other(Arc::new(Other {
name: name, name,
oid: oid, oid,
kind: kind, kind,
schema: schema, schema,
}))) })))
} }
@ -189,10 +190,7 @@ impl Field {
impl Field { impl Field {
#[doc(hidden)] #[doc(hidden)]
pub fn new(name: String, type_: Type) -> Field { pub fn new(name: String, type_: Type) -> Field {
Field { Field { name, type_ }
name: name,
type_: type_,
}
} }
} }
@ -440,11 +438,14 @@ simple_from!(i64, int8_from_sql, INT8);
simple_from!(f32, float4_from_sql, FLOAT4); simple_from!(f32, float4_from_sql, FLOAT4);
simple_from!(f64, float8_from_sql, FLOAT8); simple_from!(f64, float8_from_sql, FLOAT8);
impl<'a> FromSql<'a> for HashMap<String, Option<String>> { impl<'a, S> FromSql<'a> for HashMap<String, Option<String>, S>
where
S: Default + BuildHasher,
{
fn from_sql( fn from_sql(
_: &Type, _: &Type,
raw: &'a [u8], raw: &'a [u8],
) -> Result<HashMap<String, Option<String>>, Box<dyn Error + Sync + Send>> { ) -> Result<HashMap<String, Option<String>, S>, Box<dyn Error + Sync + Send>> {
types::hstore_from_sql(raw)? types::hstore_from_sql(raw)?
.map(|(k, v)| (k.to_owned(), v.map(str::to_owned))) .map(|(k, v)| (k.to_owned(), v.map(str::to_owned)))
.collect() .collect()
@ -739,7 +740,10 @@ simple_to!(i64, int8_to_sql, INT8);
simple_to!(f32, float4_to_sql, FLOAT4); simple_to!(f32, float4_to_sql, FLOAT4);
simple_to!(f64, float8_to_sql, FLOAT8); simple_to!(f64, float8_to_sql, FLOAT8);
impl ToSql for HashMap<String, Option<String>> { impl<H> ToSql for HashMap<String, Option<String>, H>
where
H: BuildHasher,
{
fn to_sql(&self, _: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<dyn Error + Sync + Send>> { fn to_sql(&self, _: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
types::hstore_to_sql( types::hstore_to_sql(
self.iter().map(|(k, v)| (&**k, v.as_ref().map(|v| &**v))), self.iter().map(|(k, v)| (&**k, v.as_ref().map(|v| &**v))),
@ -760,7 +764,7 @@ impl ToSql for SystemTime {
let epoch = UNIX_EPOCH + Duration::from_secs(TIME_SEC_CONVERSION); let epoch = UNIX_EPOCH + Duration::from_secs(TIME_SEC_CONVERSION);
let to_usec = let to_usec =
|d: Duration| d.as_secs() * USEC_PER_SEC + (d.subsec_nanos() as u64) / NSEC_PER_USEC; |d: Duration| d.as_secs() * USEC_PER_SEC + u64::from(d.subsec_nanos()) / NSEC_PER_USEC;
let time = match self.duration_since(epoch) { let time = match self.duration_since(epoch) {
Ok(duration) => to_usec(duration) as i64, Ok(duration) => to_usec(duration) as i64,

493
tokio-postgres/src/types/type_gen.rs
View File

@ -1,7 +1,7 @@
// Autogenerated file - DO NOT EDIT // Autogenerated file - DO NOT EDIT
use std::sync::Arc; use std::sync::Arc;
use crate::types::{Kind, Oid, Type}; use crate::types::{Type, Oid, Kind};
#[derive(PartialEq, Eq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct Other { pub struct Other {
@ -521,656 +521,493 @@ impl Inner {
pub fn kind(&self) -> &Kind { pub fn kind(&self) -> &Kind {
match *self { match *self {
Inner::Bool => { Inner::Bool => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Bytea => { Inner::Bytea => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Char => { Inner::Char => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Name => { Inner::Name => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Int8 => { Inner::Int8 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Int2 => { Inner::Int2 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Int2Vector => { Inner::Int2Vector => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int2)); &Kind::Array(Type(Inner::Int2))
V
} }
Inner::Int4 => { Inner::Int4 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Regproc => { Inner::Regproc => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Text => { Inner::Text => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Oid => { Inner::Oid => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Tid => { Inner::Tid => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Xid => { Inner::Xid => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Cid => { Inner::Cid => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::OidVector => { Inner::OidVector => {
const V: &'static Kind = &Kind::Array(Type(Inner::Oid)); &Kind::Array(Type(Inner::Oid))
V
} }
Inner::PgDdlCommand => { Inner::PgDdlCommand => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Json => { Inner::Json => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Xml => { Inner::Xml => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::XmlArray => { Inner::XmlArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Xml)); &Kind::Array(Type(Inner::Xml))
V
} }
Inner::PgNodeTree => { Inner::PgNodeTree => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::JsonArray => { Inner::JsonArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Json)); &Kind::Array(Type(Inner::Json))
V
} }
Inner::Smgr => { Inner::Smgr => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::IndexAmHandler => { Inner::IndexAmHandler => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Point => { Inner::Point => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Lseg => { Inner::Lseg => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Path => { Inner::Path => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Box => { Inner::Box => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Polygon => { Inner::Polygon => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Line => { Inner::Line => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::LineArray => { Inner::LineArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Line)); &Kind::Array(Type(Inner::Line))
V
} }
Inner::Cidr => { Inner::Cidr => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::CidrArray => { Inner::CidrArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Cidr)); &Kind::Array(Type(Inner::Cidr))
V
} }
Inner::Float4 => { Inner::Float4 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Float8 => { Inner::Float8 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Abstime => { Inner::Abstime => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Reltime => { Inner::Reltime => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Tinterval => { Inner::Tinterval => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Unknown => { Inner::Unknown => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Circle => { Inner::Circle => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::CircleArray => { Inner::CircleArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Circle)); &Kind::Array(Type(Inner::Circle))
V
} }
Inner::Macaddr8 => { Inner::Macaddr8 => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Macaddr8Array => { Inner::Macaddr8Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Macaddr8)); &Kind::Array(Type(Inner::Macaddr8))
V
} }
Inner::Money => { Inner::Money => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::MoneyArray => { Inner::MoneyArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Money)); &Kind::Array(Type(Inner::Money))
V
} }
Inner::Macaddr => { Inner::Macaddr => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Inet => { Inner::Inet => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::BoolArray => { Inner::BoolArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Bool)); &Kind::Array(Type(Inner::Bool))
V
} }
Inner::ByteaArray => { Inner::ByteaArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Bytea)); &Kind::Array(Type(Inner::Bytea))
V
} }
Inner::CharArray => { Inner::CharArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Char)); &Kind::Array(Type(Inner::Char))
V
} }
Inner::NameArray => { Inner::NameArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Name)); &Kind::Array(Type(Inner::Name))
V
} }
Inner::Int2Array => { Inner::Int2Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int2)); &Kind::Array(Type(Inner::Int2))
V
} }
Inner::Int2VectorArray => { Inner::Int2VectorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int2Vector)); &Kind::Array(Type(Inner::Int2Vector))
V
} }
Inner::Int4Array => { Inner::Int4Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int4)); &Kind::Array(Type(Inner::Int4))
V
} }
Inner::RegprocArray => { Inner::RegprocArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regproc)); &Kind::Array(Type(Inner::Regproc))
V
} }
Inner::TextArray => { Inner::TextArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Text)); &Kind::Array(Type(Inner::Text))
V
} }
Inner::TidArray => { Inner::TidArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Tid)); &Kind::Array(Type(Inner::Tid))
V
} }
Inner::XidArray => { Inner::XidArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Xid)); &Kind::Array(Type(Inner::Xid))
V
} }
Inner::CidArray => { Inner::CidArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Cid)); &Kind::Array(Type(Inner::Cid))
V
} }
Inner::OidVectorArray => { Inner::OidVectorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::OidVector)); &Kind::Array(Type(Inner::OidVector))
V
} }
Inner::BpcharArray => { Inner::BpcharArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Bpchar)); &Kind::Array(Type(Inner::Bpchar))
V
} }
Inner::VarcharArray => { Inner::VarcharArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Varchar)); &Kind::Array(Type(Inner::Varchar))
V
} }
Inner::Int8Array => { Inner::Int8Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int8)); &Kind::Array(Type(Inner::Int8))
V
} }
Inner::PointArray => { Inner::PointArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Point)); &Kind::Array(Type(Inner::Point))
V
} }
Inner::LsegArray => { Inner::LsegArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Lseg)); &Kind::Array(Type(Inner::Lseg))
V
} }
Inner::PathArray => { Inner::PathArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Path)); &Kind::Array(Type(Inner::Path))
V
} }
Inner::BoxArray => { Inner::BoxArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Box)); &Kind::Array(Type(Inner::Box))
V
} }
Inner::Float4Array => { Inner::Float4Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Float4)); &Kind::Array(Type(Inner::Float4))
V
} }
Inner::Float8Array => { Inner::Float8Array => {
const V: &'static Kind = &Kind::Array(Type(Inner::Float8)); &Kind::Array(Type(Inner::Float8))
V
} }
Inner::AbstimeArray => { Inner::AbstimeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Abstime)); &Kind::Array(Type(Inner::Abstime))
V
} }
Inner::ReltimeArray => { Inner::ReltimeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Reltime)); &Kind::Array(Type(Inner::Reltime))
V
} }
Inner::TintervalArray => { Inner::TintervalArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Tinterval)); &Kind::Array(Type(Inner::Tinterval))
V
} }
Inner::PolygonArray => { Inner::PolygonArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Polygon)); &Kind::Array(Type(Inner::Polygon))
V
} }
Inner::OidArray => { Inner::OidArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Oid)); &Kind::Array(Type(Inner::Oid))
V
} }
Inner::Aclitem => { Inner::Aclitem => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::AclitemArray => { Inner::AclitemArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Aclitem)); &Kind::Array(Type(Inner::Aclitem))
V
} }
Inner::MacaddrArray => { Inner::MacaddrArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Macaddr)); &Kind::Array(Type(Inner::Macaddr))
V
} }
Inner::InetArray => { Inner::InetArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Inet)); &Kind::Array(Type(Inner::Inet))
V
} }
Inner::Bpchar => { Inner::Bpchar => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Varchar => { Inner::Varchar => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Date => { Inner::Date => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Time => { Inner::Time => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Timestamp => { Inner::Timestamp => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::TimestampArray => { Inner::TimestampArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Timestamp)); &Kind::Array(Type(Inner::Timestamp))
V
} }
Inner::DateArray => { Inner::DateArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Date)); &Kind::Array(Type(Inner::Date))
V
} }
Inner::TimeArray => { Inner::TimeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Time)); &Kind::Array(Type(Inner::Time))
V
} }
Inner::Timestamptz => { Inner::Timestamptz => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::TimestamptzArray => { Inner::TimestamptzArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Timestamptz)); &Kind::Array(Type(Inner::Timestamptz))
V
} }
Inner::Interval => { Inner::Interval => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::IntervalArray => { Inner::IntervalArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Interval)); &Kind::Array(Type(Inner::Interval))
V
} }
Inner::NumericArray => { Inner::NumericArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Numeric)); &Kind::Array(Type(Inner::Numeric))
V
} }
Inner::CstringArray => { Inner::CstringArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Cstring)); &Kind::Array(Type(Inner::Cstring))
V
} }
Inner::Timetz => { Inner::Timetz => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::TimetzArray => { Inner::TimetzArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Timetz)); &Kind::Array(Type(Inner::Timetz))
V
} }
Inner::Bit => { Inner::Bit => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::BitArray => { Inner::BitArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Bit)); &Kind::Array(Type(Inner::Bit))
V
} }
Inner::Varbit => { Inner::Varbit => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::VarbitArray => { Inner::VarbitArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Varbit)); &Kind::Array(Type(Inner::Varbit))
V
} }
Inner::Numeric => { Inner::Numeric => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Refcursor => { Inner::Refcursor => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RefcursorArray => { Inner::RefcursorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Refcursor)); &Kind::Array(Type(Inner::Refcursor))
V
} }
Inner::Regprocedure => { Inner::Regprocedure => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Regoper => { Inner::Regoper => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Regoperator => { Inner::Regoperator => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Regclass => { Inner::Regclass => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Regtype => { Inner::Regtype => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RegprocedureArray => { Inner::RegprocedureArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regprocedure)); &Kind::Array(Type(Inner::Regprocedure))
V
} }
Inner::RegoperArray => { Inner::RegoperArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regoper)); &Kind::Array(Type(Inner::Regoper))
V
} }
Inner::RegoperatorArray => { Inner::RegoperatorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regoperator)); &Kind::Array(Type(Inner::Regoperator))
V
} }
Inner::RegclassArray => { Inner::RegclassArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regclass)); &Kind::Array(Type(Inner::Regclass))
V
} }
Inner::RegtypeArray => { Inner::RegtypeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regtype)); &Kind::Array(Type(Inner::Regtype))
V
} }
Inner::Record => { Inner::Record => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Cstring => { Inner::Cstring => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Any => { Inner::Any => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Anyarray => { Inner::Anyarray => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Void => { Inner::Void => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Trigger => { Inner::Trigger => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::LanguageHandler => { Inner::LanguageHandler => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Internal => { Inner::Internal => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Opaque => { Inner::Opaque => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Anyelement => { Inner::Anyelement => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::RecordArray => { Inner::RecordArray => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Anynonarray => { Inner::Anynonarray => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::TxidSnapshotArray => { Inner::TxidSnapshotArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::TxidSnapshot)); &Kind::Array(Type(Inner::TxidSnapshot))
V
} }
Inner::Uuid => { Inner::Uuid => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::UuidArray => { Inner::UuidArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Uuid)); &Kind::Array(Type(Inner::Uuid))
V
} }
Inner::TxidSnapshot => { Inner::TxidSnapshot => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::FdwHandler => { Inner::FdwHandler => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::PgLsn => { Inner::PgLsn => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::PgLsnArray => { Inner::PgLsnArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::PgLsn)); &Kind::Array(Type(Inner::PgLsn))
V
} }
Inner::TsmHandler => { Inner::TsmHandler => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::PgNdistinct => { Inner::PgNdistinct => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::PgDependencies => { Inner::PgDependencies => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Anyenum => { Inner::Anyenum => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::TsVector => { Inner::TsVector => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::Tsquery => { Inner::Tsquery => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::GtsVector => { Inner::GtsVector => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::TsVectorArray => { Inner::TsVectorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::TsVector)); &Kind::Array(Type(Inner::TsVector))
V
} }
Inner::GtsVectorArray => { Inner::GtsVectorArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::GtsVector)); &Kind::Array(Type(Inner::GtsVector))
V
} }
Inner::TsqueryArray => { Inner::TsqueryArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Tsquery)); &Kind::Array(Type(Inner::Tsquery))
V
} }
Inner::Regconfig => { Inner::Regconfig => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RegconfigArray => { Inner::RegconfigArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regconfig)); &Kind::Array(Type(Inner::Regconfig))
V
} }
Inner::Regdictionary => { Inner::Regdictionary => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RegdictionaryArray => { Inner::RegdictionaryArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regdictionary)); &Kind::Array(Type(Inner::Regdictionary))
V
} }
Inner::Jsonb => { Inner::Jsonb => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::JsonbArray => { Inner::JsonbArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Jsonb)); &Kind::Array(Type(Inner::Jsonb))
V
} }
Inner::AnyRange => { Inner::AnyRange => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::EventTrigger => { Inner::EventTrigger => {
const V: &'static Kind = &Kind::Pseudo; &Kind::Pseudo
V
} }
Inner::Int4Range => { Inner::Int4Range => {
const V: &'static Kind = &Kind::Range(Type(Inner::Int4)); &Kind::Range(Type(Inner::Int4))
V
} }
Inner::Int4RangeArray => { Inner::Int4RangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int4Range)); &Kind::Array(Type(Inner::Int4Range))
V
} }
Inner::NumRange => { Inner::NumRange => {
const V: &'static Kind = &Kind::Range(Type(Inner::Numeric)); &Kind::Range(Type(Inner::Numeric))
V
} }
Inner::NumRangeArray => { Inner::NumRangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::NumRange)); &Kind::Array(Type(Inner::NumRange))
V
} }
Inner::TsRange => { Inner::TsRange => {
const V: &'static Kind = &Kind::Range(Type(Inner::Timestamp)); &Kind::Range(Type(Inner::Timestamp))
V
} }
Inner::TsRangeArray => { Inner::TsRangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::TsRange)); &Kind::Array(Type(Inner::TsRange))
V
} }
Inner::TstzRange => { Inner::TstzRange => {
const V: &'static Kind = &Kind::Range(Type(Inner::Timestamptz)); &Kind::Range(Type(Inner::Timestamptz))
V
} }
Inner::TstzRangeArray => { Inner::TstzRangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::TstzRange)); &Kind::Array(Type(Inner::TstzRange))
V
} }
Inner::DateRange => { Inner::DateRange => {
const V: &'static Kind = &Kind::Range(Type(Inner::Date)); &Kind::Range(Type(Inner::Date))
V
} }
Inner::DateRangeArray => { Inner::DateRangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::DateRange)); &Kind::Array(Type(Inner::DateRange))
V
} }
Inner::Int8Range => { Inner::Int8Range => {
const V: &'static Kind = &Kind::Range(Type(Inner::Int8)); &Kind::Range(Type(Inner::Int8))
V
} }
Inner::Int8RangeArray => { Inner::Int8RangeArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Int8Range)); &Kind::Array(Type(Inner::Int8Range))
V
} }
Inner::Regnamespace => { Inner::Regnamespace => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RegnamespaceArray => { Inner::RegnamespaceArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regnamespace)); &Kind::Array(Type(Inner::Regnamespace))
V
} }
Inner::Regrole => { Inner::Regrole => {
const V: &'static Kind = &Kind::Simple; &Kind::Simple
V
} }
Inner::RegroleArray => { Inner::RegroleArray => {
const V: &'static Kind = &Kind::Array(Type(Inner::Regrole)); &Kind::Array(Type(Inner::Regrole))
V
} }
Inner::Other(ref u) => &u.kind, Inner::Other(ref u) => &u.kind,
} }
@ -1834,4 +1671,4 @@ impl Type {
/// REGROLE&#91;&#93; /// REGROLE&#91;&#93;
pub const REGROLE_ARRAY: Type = Type(Inner::RegroleArray); pub const REGROLE_ARRAY: Type = Type(Inner::RegroleArray);
} }