From ad82d28d186c2c2715d87f074479c263e45f330d Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 3 Nov 2014 21:29:16 -0800 Subject: [PATCH] Demangle PostgresType --- src/error.rs | 4 +- src/lib.rs | 23 +++-- src/types/mod.rs | 257 +++++++++++++++++++++++------------------------ tests/test.rs | 13 +-- 4 files changed, 149 insertions(+), 148 deletions(-) diff --git a/src/error.rs b/src/error.rs index 929595e8..d281688f 100644 --- a/src/error.rs +++ b/src/error.rs @@ -9,7 +9,7 @@ use openssl::ssl::error; use phf; use Result; -use types::PostgresType; +use types::Type; macro_rules! make_errors( ($($code:expr => $error:ident),+) => ( @@ -552,7 +552,7 @@ pub enum PostgresError { }, /// An attempt was made to convert between incompatible Rust and Postgres /// types - PgWrongType(PostgresType), + PgWrongType(Type), /// An attempt was made to read from a column that does not exist PgInvalidColumn, /// A value was NULL but converted to a non-nullable Rust type diff --git a/src/lib.rs b/src/lib.rs index 934aed5e..16e0656d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -133,7 +133,8 @@ use message::{Bind, Sync, Terminate}; use message::{WriteMessage, ReadMessage}; -use types::{Oid, PostgresType, ToSql, FromSql, PgUnknownType}; +#[doc(inline)] +pub use types::{Oid, Type, ToSql, FromSql}; #[macro_escape] mod macros; @@ -504,7 +505,7 @@ impl InnerConnection { } fn raw_prepare(&mut self, query: &str) - -> Result<(String, Vec, Vec)> { + -> Result<(String, Vec, Vec)> { let stmt_name = format!("s{}", self.next_stmt_id); self.next_stmt_id += 1; @@ -531,7 +532,7 @@ impl InnerConnection { let mut param_types: Vec<_> = match try_pg!(self.read_message()) { ParameterDescription { types } => { - types.iter().map(|ty| PostgresType::from_oid(*ty)).collect() + types.iter().map(|ty| Type::from_oid(*ty)).collect() } _ => bad_response!(self), }; @@ -541,7 +542,7 @@ impl InnerConnection { descriptions.into_iter().map(|RowDescriptionEntry { name, type_oid, .. }| { ResultDescription { name: name, - ty: PostgresType::from_oid(type_oid) + ty: Type::from_oid(type_oid) } }).collect() } @@ -618,9 +619,9 @@ impl InnerConnection { } fn set_type_names<'a, I>(&mut self, mut it: I) -> Result<()> - where I: Iterator<&'a mut PostgresType> { + where I: Iterator<&'a mut Type> { for ty in it { - if let &PgUnknownType { oid, ref mut name } = ty { + if let &Type::Unknown { oid, ref mut name } = ty { *name = try!(self.get_type_name(oid)); } } @@ -1111,7 +1112,7 @@ impl<'conn> Transaction<'conn> { pub struct Statement<'conn> { conn: &'conn Connection, name: String, - param_types: Vec, + param_types: Vec, result_desc: Vec, next_portal_id: Cell, finished: bool, @@ -1196,7 +1197,7 @@ impl<'conn> Statement<'conn> { } /// Returns a slice containing the expected parameter types. - pub fn param_types(&self) -> &[PostgresType] { + pub fn param_types(&self) -> &[Type] { self.param_types[] } @@ -1300,7 +1301,7 @@ pub struct ResultDescription { /// The name of the column pub name: String, /// The type of the data in the column - pub ty: PostgresType + pub ty: Type } /// An iterator over the resulting rows of a query. @@ -1538,7 +1539,7 @@ impl<'trans, 'stmt> Iterator>> for LazyRows<'trans, 'stmt> { pub struct CopyInStatement<'a> { conn: &'a Connection, name: String, - column_types: Vec, + column_types: Vec, finished: bool, } @@ -1559,7 +1560,7 @@ impl<'a> CopyInStatement<'a> { } /// Returns a slice containing the expected column types. - pub fn column_types(&self) -> &[PostgresType] { + pub fn column_types(&self) -> &[Type] { self.column_types[] } diff --git a/src/types/mod.rs b/src/types/mod.rs index 121962ff..5172740f 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -2,7 +2,6 @@ #![macro_escape] use serialize::json; -use serialize::json::Json; use std::collections::HashMap; use std::io::{AsRefReader, MemWriter, BufReader}; use std::io::util::LimitReader; @@ -75,13 +74,13 @@ macro_rules! make_postgres_type( ($(#[$doc:meta] $oid:ident => $variant:ident $(member $member:ident)*),+) => ( /// A Postgres type #[deriving(PartialEq, Eq, Clone, Show)] - pub enum PostgresType { + pub enum Type { $( #[$doc] $variant, )+ /// An unknown type - PgUnknownType { + Unknown { /// The name of the type pub name: String, /// The OID of the type @@ -89,28 +88,28 @@ macro_rules! make_postgres_type( } } - impl PostgresType { + impl Type { #[doc(hidden)] - pub fn from_oid(oid: Oid) -> PostgresType { + pub fn from_oid(oid: Oid) -> Type { match oid { - $($oid => $variant,)+ + $($oid => Type::$variant,)+ // We have to load an empty string now, it'll get filled in later - oid => PgUnknownType { name: String::new(), oid: oid } + oid => Type::Unknown { name: String::new(), oid: oid } } } #[doc(hidden)] pub fn to_oid(&self) -> Oid { match *self { - $($variant => $oid,)+ - PgUnknownType { oid, .. } => oid + $(Type::$variant => $oid,)+ + Type::Unknown { oid, .. } => oid } } - fn member_type(&self) -> PostgresType { + fn member_type(&self) -> Type { match *self { $( - $($variant => $member,)* + $(Type::$variant => Type::$member,)* )+ _ => unreachable!() } @@ -121,81 +120,81 @@ macro_rules! make_postgres_type( make_postgres_type!( #[doc="BOOL"] - BOOLOID => PgBool, + BOOLOID => Bool, #[doc="BYTEA"] - BYTEAOID => PgByteA, + BYTEAOID => ByteA, #[doc="\"char\""] - CHAROID => PgChar, + CHAROID => Char, #[doc="NAME"] - NAMEOID => PgName, + NAMEOID => Name, #[doc="INT8/BIGINT"] - INT8OID => PgInt8, + INT8OID => Int8, #[doc="INT2/SMALLINT"] - INT2OID => PgInt2, + INT2OID => Int2, #[doc="INT4/INT"] - INT4OID => PgInt4, + INT4OID => Int4, #[doc="TEXT"] - TEXTOID => PgText, + TEXTOID => Text, #[doc="JSON"] - JSONOID => PgJson, + JSONOID => Json, #[doc="JSON[]"] - JSONARRAYOID => PgJsonArray member PgJson, + JSONARRAYOID => JsonArray member Json, #[doc="FLOAT4/REAL"] - FLOAT4OID => PgFloat4, + FLOAT4OID => Float4, #[doc="FLOAT8/DOUBLE PRECISION"] - FLOAT8OID => PgFloat8, + FLOAT8OID => Float8, #[doc="BOOL[]"] - BOOLARRAYOID => PgBoolArray member PgBool, + BOOLARRAYOID => BoolArray member Bool, #[doc="BYTEA[]"] - BYTEAARRAYOID => PgByteAArray member PgByteA, + BYTEAARRAYOID => ByteAArray member ByteA, #[doc="\"char\"[]"] - CHARARRAYOID => PgCharArray member PgChar, + CHARARRAYOID => CharArray member Char, #[doc="NAME[]"] - NAMEARRAYOID => PgNameArray member PgName, + NAMEARRAYOID => NameArray member Name, #[doc="INT2[]"] - INT2ARRAYOID => PgInt2Array member PgInt2, + INT2ARRAYOID => Int2Array member Int2, #[doc="INT4[]"] - INT4ARRAYOID => PgInt4Array member PgInt4, + INT4ARRAYOID => Int4Array member Int4, #[doc="TEXT[]"] - TEXTARRAYOID => PgTextArray member PgText, + TEXTARRAYOID => TextArray member Text, #[doc="CHAR(n)[]"] - BPCHARARRAYOID => PgCharNArray member PgCharN, + BPCHARARRAYOID => CharNArray member CharN, #[doc="VARCHAR[]"] - VARCHARARRAYOID => PgVarcharArray member PgVarchar, + VARCHARARRAYOID => VarcharArray member Varchar, #[doc="INT8[]"] - INT8ARRAYOID => PgInt8Array member PgInt8, + INT8ARRAYOID => Int8Array member Int8, #[doc="FLOAT4[]"] - FLOAT4ARRAYOID => PgFloat4Array member PgFloat4, + FLOAT4ARRAYOID => Float4Array member Float4, #[doc="FLOAT8[]"] - FLAOT8ARRAYOID => PgFloat8Array member PgFloat8, + FLAOT8ARRAYOID => Float8Array member Float8, #[doc="TIMESTAMP"] - TIMESTAMPOID => PgTimestamp, + TIMESTAMPOID => Timestamp, #[doc="TIMESTAMP[]"] - TIMESTAMPARRAYOID => PgTimestampArray member PgTimestamp, + TIMESTAMPARRAYOID => TimestampArray member Timestamp, #[doc="TIMESTAMP WITH TIME ZONE"] - TIMESTAMPZOID => PgTimestampTZ, + TIMESTAMPZOID => TimestampTZ, #[doc="TIMESTAMP WITH TIME ZONE[]"] - TIMESTAMPZARRAYOID => PgTimestampTZArray member PgTimestampTZ, + TIMESTAMPZARRAYOID => TimestampTZArray member TimestampTZ, #[doc="CHAR(n)/CHARACTER(n)"] - BPCHAROID => PgCharN, + BPCHAROID => CharN, #[doc="VARCHAR/CHARACTER VARYING"] - VARCHAROID => PgVarchar, + VARCHAROID => Varchar, #[doc="INT4RANGE"] - INT4RANGEOID => PgInt4Range, + INT4RANGEOID => Int4Range, #[doc="INT4RANGE[]"] - INT4RANGEARRAYOID => PgInt4RangeArray member PgInt4Range, + INT4RANGEARRAYOID => Int4RangeArray member Int4Range, #[doc="TSRANGE"] - TSRANGEOID => PgTsRange, + TSRANGEOID => TsRange, #[doc="TSRANGE[]"] - TSRANGEARRAYOID => PgTsRangeArray member PgTsRange, + TSRANGEARRAYOID => TsRangeArray member TsRange, #[doc="TSTZRANGE"] - TSTZRANGEOID => PgTstzRange, + TSTZRANGEOID => TstzRange, #[doc="TSTZRANGE[]"] - TSTZRANGEARRAYOID => PgTstzRangeArray member PgTstzRange, + TSTZRANGEARRAYOID => TstzRangeArray member TstzRange, #[doc="INT8RANGE"] - INT8RANGEOID => PgInt8Range, + INT8RANGEOID => Int8Range, #[doc="INT8RANGE[]"] - INT8RANGEARRAYOID => PgInt8RangeArray member PgInt8Range + INT8RANGEARRAYOID => Int8RangeArray member Int8Range ) macro_rules! check_types( @@ -212,7 +211,7 @@ pub trait FromSql { /// Creates a new value of this type from a buffer of Postgres data. /// /// If the value was `NULL`, the buffer will be `None`. - fn from_sql(ty: &PostgresType, raw: &Option>) -> Result; + fn from_sql(ty: &Type, raw: &Option>) -> Result; } #[doc(hidden)] @@ -321,8 +320,8 @@ from_range_impl!(i32) from_range_impl!(i64) from_range_impl!(Timespec) -impl RawFromSql for Json { - fn raw_from_sql(raw: &mut R) -> Result { +impl RawFromSql for json::Json { + fn raw_from_sql(raw: &mut R) -> Result { json::from_reader(raw).map_err(|_| PgBadData) } } @@ -330,7 +329,7 @@ impl RawFromSql for Json { macro_rules! from_map_impl( ($($expected:pat)|+, $t:ty, $blk:expr) => ( impl FromSql for Option<$t> { - fn from_sql(ty: &PostgresType, raw: &Option>) + fn from_sql(ty: &Type, raw: &Option>) -> Result> { check_types!($($expected)|+, ty) match *raw { @@ -341,7 +340,7 @@ macro_rules! from_map_impl( } impl FromSql for $t { - fn from_sql(ty: &PostgresType, raw: &Option>) + fn from_sql(ty: &Type, raw: &Option>) -> Result<$t> { // FIXME when you can specify Self types properly let ret: Result> = FromSql::from_sql(ty, raw); @@ -364,21 +363,21 @@ macro_rules! from_raw_from_impl( ) ) -from_raw_from_impl!(PgBool, bool) -from_raw_from_impl!(PgByteA, Vec) -from_raw_from_impl!(PgVarchar | PgText | PgCharN | PgName, String) -from_raw_from_impl!(PgChar, i8) -from_raw_from_impl!(PgInt2, i16) -from_raw_from_impl!(PgInt4, i32) -from_raw_from_impl!(PgInt8, i64) -from_raw_from_impl!(PgFloat4, f32) -from_raw_from_impl!(PgFloat8, f64) -from_raw_from_impl!(PgJson, Json) +from_raw_from_impl!(Bool, bool) +from_raw_from_impl!(ByteA, Vec) +from_raw_from_impl!(Varchar | Text | CharN | Name, String) +from_raw_from_impl!(Char, i8) +from_raw_from_impl!(Int2, i16) +from_raw_from_impl!(Int4, i32) +from_raw_from_impl!(Int8, i64) +from_raw_from_impl!(Float4, f32) +from_raw_from_impl!(Float8, f64) +from_raw_from_impl!(Json, json::Json) -from_raw_from_impl!(PgTimestamp | PgTimestampTZ, Timespec) -from_raw_from_impl!(PgInt4Range, Range) -from_raw_from_impl!(PgInt8Range, Range) -from_raw_from_impl!(PgTsRange | PgTstzRange, Range) +from_raw_from_impl!(Timestamp | TimestampTZ, Timespec) +from_raw_from_impl!(Int4Range, Range) +from_raw_from_impl!(Int8Range, Range) +from_raw_from_impl!(TsRange | TstzRange, Range) macro_rules! from_array_impl( ($($oid:ident)|+, $t:ty) => ( @@ -415,26 +414,26 @@ macro_rules! from_array_impl( ) ) -from_array_impl!(PgBoolArray, bool) -from_array_impl!(PgByteAArray, Vec) -from_array_impl!(PgCharArray, i8) -from_array_impl!(PgInt2Array, i16) -from_array_impl!(PgInt4Array, i32) -from_array_impl!(PgTextArray | PgCharNArray | PgVarcharArray | PgNameArray, String) -from_array_impl!(PgInt8Array, i64) -from_array_impl!(PgTimestampArray | PgTimestampTZArray, Timespec) -from_array_impl!(PgJsonArray, Json) -from_array_impl!(PgFloat4Array, f32) -from_array_impl!(PgFloat8Array, f64) -from_array_impl!(PgInt4RangeArray, Range) -from_array_impl!(PgTsRangeArray | PgTstzRangeArray, Range) -from_array_impl!(PgInt8RangeArray, Range) +from_array_impl!(BoolArray, bool) +from_array_impl!(ByteAArray, Vec) +from_array_impl!(CharArray, i8) +from_array_impl!(Int2Array, i16) +from_array_impl!(Int4Array, i32) +from_array_impl!(TextArray | CharNArray | VarcharArray | NameArray, String) +from_array_impl!(Int8Array, i64) +from_array_impl!(TimestampArray | TimestampTZArray, Timespec) +from_array_impl!(JsonArray, json::Json) +from_array_impl!(Float4Array, f32) +from_array_impl!(Float8Array, f64) +from_array_impl!(Int4RangeArray, Range) +from_array_impl!(TsRangeArray | TstzRangeArray, Range) +from_array_impl!(Int8RangeArray, Range) impl FromSql for Option>> { - fn from_sql(ty: &PostgresType, raw: &Option>) + fn from_sql(ty: &Type, raw: &Option>) -> Result>>> { match *ty { - PgUnknownType { ref name, .. } if "hstore" == name[] => {} + Type::Unknown { ref name, .. } if "hstore" == name[] => {} _ => return Err(PgWrongType(ty.clone())) } @@ -474,7 +473,7 @@ impl FromSql for Option>> { } impl FromSql for HashMap> { - fn from_sql(ty: &PostgresType, raw: &Option>) + fn from_sql(ty: &Type, raw: &Option>) -> Result>> { // FIXME when you can specify Self types properly let ret: Result>>> = @@ -491,7 +490,7 @@ impl FromSql for HashMap> { pub trait ToSql { /// Converts the value of `self` into the binary format appropriate for the /// Postgres backend. - fn to_sql(&self, ty: &PostgresType) -> Result>>; + fn to_sql(&self, ty: &Type) -> Result>>; } #[doc(hidden)] @@ -594,7 +593,7 @@ to_range_impl!(i32) to_range_impl!(i64) to_range_impl!(Timespec) -impl RawToSql for Json { +impl RawToSql for json::Json { fn raw_to_sql(&self, raw: &mut W) -> Result<()> { Ok(try_pg!(self.to_writer(raw as &mut Writer))) } @@ -603,7 +602,7 @@ impl RawToSql for Json { macro_rules! to_option_impl( ($($oid:pat)|+, $t:ty) => ( impl ToSql for Option<$t> { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { check_types!($($oid)|+, ty) match *self { @@ -618,7 +617,7 @@ macro_rules! to_option_impl( macro_rules! to_option_impl_lifetime( ($($oid:pat)|+, $t:ty) => ( impl<'a> ToSql for Option<$t> { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { check_types!($($oid)|+, ty) match *self { @@ -633,7 +632,7 @@ macro_rules! to_option_impl_lifetime( macro_rules! to_raw_to_impl( ($($oid:ident)|+, $t:ty) => ( impl ToSql for $t { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { check_types!($($oid)|+, ty) let mut writer = MemWriter::new(); @@ -646,44 +645,44 @@ macro_rules! to_raw_to_impl( ) ) -to_raw_to_impl!(PgBool, bool) -to_raw_to_impl!(PgByteA, Vec) -to_raw_to_impl!(PgVarchar | PgText | PgCharN | PgName, String) -to_raw_to_impl!(PgJson, Json) -to_raw_to_impl!(PgChar, i8) -to_raw_to_impl!(PgInt2, i16) -to_raw_to_impl!(PgInt4, i32) -to_raw_to_impl!(PgInt8, i64) -to_raw_to_impl!(PgFloat4, f32) -to_raw_to_impl!(PgFloat8, f64) -to_raw_to_impl!(PgInt4Range, Range) -to_raw_to_impl!(PgInt8Range, Range) -to_raw_to_impl!(PgTsRange | PgTstzRange, Range) +to_raw_to_impl!(Bool, bool) +to_raw_to_impl!(ByteA, Vec) +to_raw_to_impl!(Varchar | Text | CharN | Name, String) +to_raw_to_impl!(Json, json::Json) +to_raw_to_impl!(Char, i8) +to_raw_to_impl!(Int2, i16) +to_raw_to_impl!(Int4, i32) +to_raw_to_impl!(Int8, i64) +to_raw_to_impl!(Float4, f32) +to_raw_to_impl!(Float8, f64) +to_raw_to_impl!(Int4Range, Range) +to_raw_to_impl!(Int8Range, Range) +to_raw_to_impl!(TsRange | TstzRange, Range) impl<'a> ToSql for &'a str { - fn to_sql(&self, ty: &PostgresType) -> Result>> { - check_types!(PgVarchar | PgText | PgCharN | PgName, ty) + fn to_sql(&self, ty: &Type) -> Result>> { + check_types!(Varchar | Text | CharN | Name, ty) Ok(Some(self.as_bytes().to_vec())) } } -to_option_impl_lifetime!(PgVarchar | PgText | PgCharN | PgName, &'a str) +to_option_impl_lifetime!(Varchar | Text | CharN | Name, &'a str) impl<'a> ToSql for &'a [u8] { - fn to_sql(&self, ty: &PostgresType) -> Result>> { - check_types!(PgByteA, ty) + fn to_sql(&self, ty: &Type) -> Result>> { + check_types!(ByteA, ty) Ok(Some(self.to_vec())) } } -to_option_impl_lifetime!(PgByteA, &'a [u8]) +to_option_impl_lifetime!(ByteA, &'a [u8]) -to_raw_to_impl!(PgTimestamp | PgTimestampTZ, Timespec) +to_raw_to_impl!(Timestamp | TimestampTZ, Timespec) macro_rules! to_array_impl( ($($oid:ident)|+, $t:ty) => ( impl ToSql for ArrayBase> { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { check_types!($($oid)|+, ty) let mut buf = MemWriter::new(); @@ -717,25 +716,25 @@ macro_rules! to_array_impl( ) ) -to_array_impl!(PgBoolArray, bool) -to_array_impl!(PgByteAArray, Vec) -to_array_impl!(PgCharArray, i8) -to_array_impl!(PgInt2Array, i16) -to_array_impl!(PgInt4Array, i32) -to_array_impl!(PgInt8Array, i64) -to_array_impl!(PgTextArray | PgCharNArray | PgVarcharArray | PgNameArray, String) -to_array_impl!(PgTimestampArray | PgTimestampTZArray, Timespec) -to_array_impl!(PgFloat4Array, f32) -to_array_impl!(PgFloat8Array, f64) -to_array_impl!(PgInt4RangeArray, Range) -to_array_impl!(PgTsRangeArray | PgTstzRangeArray, Range) -to_array_impl!(PgInt8RangeArray, Range) -to_array_impl!(PgJsonArray, Json) +to_array_impl!(BoolArray, bool) +to_array_impl!(ByteAArray, Vec) +to_array_impl!(CharArray, i8) +to_array_impl!(Int2Array, i16) +to_array_impl!(Int4Array, i32) +to_array_impl!(Int8Array, i64) +to_array_impl!(TextArray | CharNArray | VarcharArray | NameArray, String) +to_array_impl!(TimestampArray | TimestampTZArray, Timespec) +to_array_impl!(Float4Array, f32) +to_array_impl!(Float8Array, f64) +to_array_impl!(Int4RangeArray, Range) +to_array_impl!(TsRangeArray | TstzRangeArray, Range) +to_array_impl!(Int8RangeArray, Range) +to_array_impl!(JsonArray, json::Json) impl ToSql for HashMap> { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { match *ty { - PgUnknownType { ref name, .. } if "hstore" == name[] => {} + Type::Unknown { ref name, .. } if "hstore" == name[] => {} _ => return Err(PgWrongType(ty.clone())) } @@ -761,9 +760,9 @@ impl ToSql for HashMap> { } impl ToSql for Option>> { - fn to_sql(&self, ty: &PostgresType) -> Result>> { + fn to_sql(&self, ty: &Type) -> Result>> { match *ty { - PgUnknownType { ref name, .. } if "hstore" == name[] => {} + Type::Unknown { ref name, .. } if "hstore" == name[] => {} _ => return Err(PgWrongType(ty.clone())) } diff --git a/tests/test.rs b/tests/test.rs index 06e5c8ae..acdd7dac 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -18,7 +18,9 @@ use postgres::{NoticeHandler, ResultDescription, RequireSsl, PreferSsl, - NoSsl}; + NoSsl, + Type, + ToSql}; use postgres::error::{PgConnectDbError, PgDbError, PgWrongConnection, @@ -36,7 +38,6 @@ use postgres::error::{PgConnectDbError, InvalidCatalogName, PgWrongTransaction, CardinalityViolation}; -use postgres::types::{PgInt4, PgVarchar, ToSql}; macro_rules! or_panic( ($e:expr) => ( @@ -441,7 +442,7 @@ fn test_lazy_query_wrong_conn() { fn test_param_types() { let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &NoSsl)); let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR")); - assert_eq!(stmt.param_types(), [PgInt4, PgVarchar][]); + assert_eq!(stmt.param_types(), [Type::Int4, Type::Varchar][]); } #[test] @@ -449,8 +450,8 @@ fn test_result_descriptions() { let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &NoSsl)); let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b")); assert!(stmt.result_descriptions() == - [ResultDescription { name: "a".to_string(), ty: PgInt4}, - ResultDescription { name: "b".to_string(), ty: PgVarchar}]); + [ResultDescription { name: "a".to_string(), ty: Type::Int4}, + ResultDescription { name: "b".to_string(), ty: Type::Varchar}]); } #[test] @@ -762,7 +763,7 @@ fn test_copy_in_bad_type() { let res = stmt.execute(data.iter().map(|r| r.iter().map(|&e| e))); match res { - Err(PgDbError(ref err)) if err.message[].contains("Unexpected type PgVarchar") => {} + Err(PgDbError(ref err)) if err.message[].contains("Unexpected type Varchar") => {} Err(err) => panic!("unexpected error {}", err), _ => panic!("Expected error"), }