Support conversion of the UNKNOWN type to String

Closes #256

Author: sfackler

postgres-shared/src/types/mod.rs

@@ -156,11 +156,11 @@ impl Other {
     #[doc(hidden)]
     pub fn new(name: String, oid: Oid, kind: Kind, schema: String) -> Other {
         Other(Arc::new(OtherInner {
-            name: name,
-            oid: oid,
-            kind: kind,
-            schema: schema,
-        }))
+                           name: name,
+                           oid: oid,
+                           kind: kind,
+                           schema: schema,
+                       }))
     }
 }
 
@@ -236,19 +236,19 @@ impl WrongType {
 /// The following implementations are provided by this crate, along with the
 /// corresponding Postgres types:
 ///
-/// | Rust type                         | Postgres type(s)                     |
-/// |-----------------------------------|--------------------------------------|
-/// | `bool`                            | BOOL                                 |
-/// | `i8`                              | "char"                               |
-/// | `i16`                             | SMALLINT, SMALLSERIAL                |
-/// | `i32`                             | INT, SERIAL                          |
-/// | `u32`                             | OID                                  |
-/// | `i64`                             | BIGINT, BIGSERIAL                    |
-/// | `f32`                             | REAL                                 |
-/// | `f64`                             | DOUBLE PRECISION                     |
-/// | `String`                          | VARCHAR, CHAR(n), TEXT, CITEXT, NAME |
-/// | `Vec<u8>`                         | BYTEA                                |
-/// | `HashMap<String, Option<String>>` | HSTORE                               |
+/// | Rust type                         | Postgres type(s)                              |
+/// |-----------------------------------|-----------------------------------------------|
+/// | `bool`                            | BOOL                                          |
+/// | `i8`                              | "char"                                        |
+/// | `i16`                             | SMALLINT, SMALLSERIAL                         |
+/// | `i32`                             | INT, SERIAL                                   |
+/// | `u32`                             | OID                                           |
+/// | `i64`                             | BIGINT, BIGSERIAL                             |
+/// | `f32`                             | REAL                                          |
+/// | `f64`                             | DOUBLE PRECISION                              |
+/// | `String`                          | VARCHAR, CHAR(n), TEXT, CITEXT, NAME, UNKNOWN |
+/// | `Vec<u8>`                         | BYTEA                                         |
+/// | `HashMap<String, Option<String>>` | HSTORE                                        |
 ///
 /// In addition, some implementations are provided for types in third party
 /// crates. These are disabled by default; to opt into one of these
@@ -288,9 +288,7 @@ pub trait FromSql: Sized {
     ///
     /// The caller of this method is responsible for ensuring that this type
     /// is compatible with the Postgres `Type`.
-    fn from_sql(ty: &Type,
-                raw: &[u8])
-                -> Result<Self, Box<Error + Sync + Send>>;
+    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Self, Box<Error + Sync + Send>>;
 
     /// Creates a new value of this type from a `NULL` SQL value.
     ///
@@ -306,9 +304,7 @@ pub trait FromSql: Sized {
 
     /// A convenience function that delegates to `from_sql` and `from_sql_null` depending on the
     /// value of `raw`.
-    fn from_sql_nullable(ty: &Type,
-                         raw: Option<&[u8]>)
-                         -> Result<Self, Box<Error + Sync + Send>> {
+    fn from_sql_nullable(ty: &Type, raw: Option<&[u8]>) -> Result<Self, Box<Error + Sync + Send>> {
         match raw {
             Some(raw) => Self::from_sql(ty, raw),
             None => Self::from_sql_null(ty),
@@ -321,9 +317,7 @@ pub trait FromSql: Sized {
 }
 
 impl<T: FromSql> FromSql for Option<T> {
-    fn from_sql(ty: &Type,
-                raw: &[u8])
-                -> Result<Option<T>, Box<Error + Sync + Send>> {
+    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Option<T>, Box<Error + Sync + Send>> {
         <T as FromSql>::from_sql(ty, raw).map(Some)
     }
 
@@ -337,9 +331,7 @@ impl<T: FromSql> FromSql for Option<T> {
 }
 
 impl<T: FromSql> FromSql for Vec<T> {
-    fn from_sql(ty: &Type,
-                raw: &[u8])
-                -> Result<Vec<T>, Box<Error + Sync + Send>> {
+    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Vec<T>, Box<Error + Sync + Send>> {
         let member_type = match *ty.kind() {
             Kind::Array(ref member) => member,
             _ => panic!("expected array type"),
@@ -350,7 +342,8 @@ impl<T: FromSql> FromSql for Vec<T> {
             return Err("array contains too many dimensions".into());
         }
 
-        array.values()
+        array
+            .values()
             .and_then(|v| T::from_sql_nullable(member_type, v))
             .collect()
     }
@@ -364,9 +357,7 @@ impl<T: FromSql> FromSql for Vec<T> {
 }
 
 impl FromSql for Vec<u8> {
-    fn from_sql(_: &Type,
-                raw: &[u8])
-                -> Result<Vec<u8>, Box<Error + Sync + Send>> {
+    fn from_sql(_: &Type, raw: &[u8]) -> Result<Vec<u8>, Box<Error + Sync + Send>> {
         Ok(types::bytea_from_sql(raw).to_owned())
     }
 
@@ -380,7 +371,7 @@ impl FromSql for String {
 
     fn accepts(ty: &Type) -> bool {
         match *ty {
-            Type::Varchar | Type::Text | Type::Bpchar | Type::Name => true,
+            Type::Varchar | Type::Text | Type::Bpchar | Type::Name | Type::Unknown => true,
             Type::Other(ref u) if u.name() == "citext" => true,
             _ => false,
         }
@@ -500,10 +491,7 @@ pub trait ToSql: fmt::Debug {
     /// The return value indicates if this value should be represented as
     /// `NULL`. If this is the case, implementations **must not** write
     /// anything to `out`.
-    fn to_sql(&self,
-              ty: &Type,
-              out: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>>
+    fn to_sql(&self, ty: &Type, out: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>>
         where Self: Sized;
 
     /// Determines if a value of this type can be converted to the specified
@@ -523,10 +511,7 @@ pub trait ToSql: fmt::Debug {
 impl<'a, T> ToSql for &'a T
     where T: ToSql
 {
-    fn to_sql(&self,
-              ty: &Type,
-              out: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, out: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         (*self).to_sql(ty, out)
     }
 
@@ -538,10 +523,7 @@ impl<'a, T> ToSql for &'a T
 }
 
 impl<T: ToSql> ToSql for Option<T> {
-    fn to_sql(&self,
-              ty: &Type,
-              out: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, out: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         match *self {
             Some(ref val) => val.to_sql(ty, out),
             None => Ok(IsNull::Yes),
@@ -556,10 +538,7 @@ impl<T: ToSql> ToSql for Option<T> {
 }
 
 impl<'a, T: ToSql> ToSql for &'a [T] {
-    fn to_sql(&self,
-              ty: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         let member_type = match *ty.kind() {
             Kind::Array(ref member) => member,
             _ => panic!("expected array type"),
@@ -571,16 +550,14 @@ impl<'a, T: ToSql> ToSql for &'a [T] {
         };
 
         types::array_to_sql(Some(dimension),
-                                 true,
-                                 member_type.oid(),
-                                 self.iter(),
-                                 |e, w| {
-                                     match e.to_sql(member_type, w)? {
-                                         IsNull::No => Ok(postgres_protocol::IsNull::No),
-                                         IsNull::Yes => Ok(postgres_protocol::IsNull::Yes),
-                                     }
-                                 },
-                                 w)?;
+                            true,
+                            member_type.oid(),
+                            self.iter(),
+                            |e, w| match e.to_sql(member_type, w)? {
+                                IsNull::No => Ok(postgres_protocol::IsNull::No),
+                                IsNull::Yes => Ok(postgres_protocol::IsNull::Yes),
+                            },
+                            w)?;
         Ok(IsNull::No)
     }
 
@@ -595,10 +572,7 @@ impl<'a, T: ToSql> ToSql for &'a [T] {
 }
 
 impl<'a> ToSql for &'a [u8] {
-    fn to_sql(&self,
-              _: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, _: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         types::bytea_to_sql(*self, w);
         Ok(IsNull::No)
     }
@@ -609,10 +583,7 @@ impl<'a> ToSql for &'a [u8] {
 }
 
 impl<T: ToSql> ToSql for Vec<T> {
-    fn to_sql(&self,
-              ty: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         <&[T] as ToSql>::to_sql(&&**self, ty, w)
     }
 
@@ -624,10 +595,7 @@ impl<T: ToSql> ToSql for Vec<T> {
 }
 
 impl ToSql for Vec<u8> {
-    fn to_sql(&self,
-              ty: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         <&[u8] as ToSql>::to_sql(&&**self, ty, w)
     }
 
@@ -639,10 +607,7 @@ impl ToSql for Vec<u8> {
 }
 
 impl<'a> ToSql for &'a str {
-    fn to_sql(&self,
-              _: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, _: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         types::text_to_sql(*self, w);
         Ok(IsNull::No)
     }
@@ -659,10 +624,7 @@ impl<'a> ToSql for &'a str {
 }
 
 impl ToSql for String {
-    fn to_sql(&self,
-              ty: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         <&str as ToSql>::to_sql(&&**self, ty, w)
     }
 
@@ -701,11 +663,9 @@ simple_to!(f32, float4_to_sql, Type::Float4);
 simple_to!(f64, float8_to_sql, Type::Float8);
 
 impl ToSql for HashMap<String, Option<String>> {
-    fn to_sql(&self,
-              _: &Type,
-              w: &mut Vec<u8>)
-              -> Result<IsNull, Box<Error + Sync + Send>> {
-        types::hstore_to_sql(self.iter().map(|(k, v)| (&**k, v.as_ref().map(|v| &**v))), w)?;
+    fn to_sql(&self, _: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
+        types::hstore_to_sql(self.iter().map(|(k, v)| (&**k, v.as_ref().map(|v| &**v))),
+                             w)?;
         Ok(IsNull::No)
     }