Add FromSql::from_sql_nullable

Also clean up logic for type info queries to avoid panics on bogus
responses.

Author: sfackler

src/lib.rs

@@ -124,7 +124,7 @@ const TYPEINFO_COMPOSITE_QUERY: &'static str = "__typeinfo_composite";
 /// A type alias of the result returned by many methods.
 pub type Result<T> = result::Result<T, Error>;
 
-/// Trait for types that can handle Postgres notice messages
+/// A trait implemented by types that can handle Postgres notice messages.
 ///
 /// It is implemented for all `Send + FnMut(DbError)` closures.
 pub trait HandleNotice: Send {
@@ -681,29 +681,23 @@ impl InnerConnection {
         try!(self.read_rows(&mut rows));
         let row = rows.pop_front().unwrap();
 
+        let get_raw = |i| row.get(i).and_then(|r| r.as_ref().map(|r| &**r));
+
         let (name, type_, elem_oid, rngsubtype, basetype, schema, relid) = {
             let ctx = SessionInfo::new(&self.parameters);
-            let name = try!(String::from_sql(&Type::Name, row[0].as_ref().unwrap(), &ctx)
+            let name = try!(String::from_sql_nullable(&Type::Name, get_raw(0), &ctx)
                 .map_err(Error::Conversion));
-            let type_ = try!(i8::from_sql(&Type::Char, row[1].as_ref().unwrap(), &ctx)
+            let type_ = try!(i8::from_sql_nullable(&Type::Char, get_raw(1), &ctx)
                 .map_err(Error::Conversion));
-            let elem_oid = try!(Oid::from_sql(&Type::Oid, row[2].as_ref().unwrap(), &ctx)
+            let elem_oid = try!(Oid::from_sql_nullable(&Type::Oid, get_raw(2), &ctx)
                 .map_err(Error::Conversion));
-            let rngsubtype = match row[3] {
-                Some(ref data) => {
-                    try!(Option::<Oid>::from_sql(&Type::Oid, data, &ctx)
-                        .map_err(Error::Conversion))
-                }
-                None => {
-                    try!(Option::<Oid>::from_sql_null(&Type::Oid, &ctx).map_err(Error::Conversion))
-                }
-            };
-            let basetype = try!(Oid::from_sql(&Type::Oid, row[4].as_ref().unwrap(), &ctx)
+            let rngsubtype = try!(Option::<Oid>::from_sql_nullable(&Type::Oid, get_raw(3), &ctx)
                 .map_err(Error::Conversion));
-            let schema =
-                try!(String::from_sql(&Type::Name, row[5].as_ref().unwrap(), &ctx)
-                    .map_err(Error::Conversion));
-            let relid = try!(Oid::from_sql(&Type::Oid, row[6].as_ref().unwrap(), &ctx)
+            let basetype = try!(Oid::from_sql_nullable(&Type::Oid, get_raw(4), &ctx)
+                .map_err(Error::Conversion));
+            let schema = try!(String::from_sql_nullable(&Type::Name, get_raw(5), &ctx)
+                .map_err(Error::Conversion));
+            let relid = try!(Oid::from_sql_nullable(&Type::Oid, get_raw(6), &ctx)
                 .map_err(Error::Conversion));
             (name, type_, elem_oid, rngsubtype, basetype, schema, relid)
         };
@@ -763,7 +757,8 @@ impl InnerConnection {
         let ctx = SessionInfo::new(&self.parameters);
         let mut variants = vec![];
         for row in rows {
-            variants.push(try!(String::from_sql(&Type::Name, row[0].as_ref().unwrap(), &ctx)
+            let raw = row.get(0).and_then(|r| r.as_ref().map(|r| &**r));
+            variants.push(try!(String::from_sql_nullable(&Type::Name, raw, &ctx)
                     .map_err(Error::Conversion)));
         }
 
@@ -796,11 +791,11 @@ impl InnerConnection {
         let mut fields = vec![];
         for row in rows {
             let (name, type_) = {
+                let get_raw = |i| row.get(i).and_then(|r| r.as_ref().map(|r| &**r));
                 let ctx = SessionInfo::new(&self.parameters);
-                let name =
-                    try!(String::from_sql(&Type::Name, row[0].as_ref().unwrap(), &ctx)
-                        .map_err(Error::Conversion));
-                let type_ = try!(Oid::from_sql(&Type::Oid, row[1].as_ref().unwrap(), &ctx)
+                let name = try!(String::from_sql_nullable(&Type::Name, get_raw(0), &ctx)
+                    .map_err(Error::Conversion));
+                let type_ = try!(Oid::from_sql_nullable(&Type::Oid, get_raw(1), &ctx)
                     .map_err(Error::Conversion));
                 (name, type_)
             };

src/rows.rs

@@ -237,12 +237,9 @@ impl<'a> Row<'a> {
             return Some(Err(Error::Conversion(Box::new(WrongType::new(ty.clone())))));
         }
         let conn = self.stmt.conn().0.borrow();
-        let value = match self.data[idx] {
-            Some(ref data) => {
-                FromSql::from_sql(ty, data, &SessionInfo::new(&conn.parameters))
-            }
-            None => FromSql::from_sql_null(ty, &SessionInfo::new(&conn.parameters)),
-        };
+        let value = FromSql::from_sql_nullable(ty,
+                                               self.data[idx].as_ref().map(|r| &**r),
+                                               &SessionInfo::new(&conn.parameters));
         Some(value.map_err(Error::Conversion))
     }
 

src/types/mod.rs

@@ -325,6 +325,18 @@ pub trait FromSql: Sized {
         Err(Box::new(WasNull))
     }
 
+    /// 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]>,
+                         ctx: &SessionInfo)
+                         -> Result<Self, Box<Error + Sync + Send>> {
+        match raw {
+            Some(raw) => Self::from_sql(ty, raw, ctx),
+            None => Self::from_sql_null(ty, ctx),
+        }
+    }
+
     /// Determines if a value of this type can be created from the specified
     /// Postgres `Type`.
     fn accepts(ty: &Type) -> bool;
@@ -363,12 +375,7 @@ impl<T: FromSql> FromSql for Vec<T> {
         }
 
         array.values()
-            .and_then(|v| {
-                match v {
-                    Some(v) => T::from_sql(member_type, v, info),
-                    None => T::from_sql_null(member_type, info),
-                }
-            })
+            .and_then(|v| T::from_sql_nullable(member_type, v, info))
             .collect()
     }