Remove Error::InvalidColumn

Change get_opt to return an Option<Result<T>> as its name would hint

Author: sfackler

src/error.rs

@@ -278,8 +278,6 @@ pub enum Error {
     /// An attempt was made to convert between incompatible Rust and Postgres
     /// types.
     WrongType(Type),
-    /// An attempt was made to read from a column that does not exist.
-    InvalidColumn,
     /// An error converting between Postgres and Rust types.
     Conversion(Box<error::Error + Sync + Send>),
 }
@@ -292,7 +290,6 @@ impl fmt::Display for Error {
             Error::IoError(ref err) => write!(fmt, ": {}", err),
             Error::WrongType(ref ty) => write!(fmt, ": saw type {:?}", ty),
             Error::Conversion(ref err) => write!(fmt, ": {}", err),
-            _ => Ok(()),
         }
     }
 }
@@ -303,7 +300,6 @@ impl error::Error for Error {
             Error::DbError(_) => "Error reported by Postgres",
             Error::IoError(_) => "Error communicating with the server",
             Error::WrongType(_) => "Unexpected type",
-            Error::InvalidColumn => "Invalid column",
             Error::Conversion(_) => "Error converting between Postgres and Rust types",
         }
     }

src/rows.rs

@@ -190,8 +190,9 @@ impl<'a> Row<'a> {
               T: FromSql
     {
         match self.get_inner(&idx) {
-            Ok(ok) => ok,
-            Err(err) => panic!("error retrieving column {:?}: {:?}", idx, err),
+            Some(Ok(ok)) => ok,
+            Some(Err(err)) => panic!("error retrieving column {:?}: {:?}", idx, err),
+            None => panic!("no such column {:?}"),
         }
     }
 
@@ -200,29 +201,35 @@ impl<'a> Row<'a> {
     /// A field can be accessed by the name or index of its column, though
     /// access by index is more efficient. Rows are 0-indexed.
     ///
-    /// Returns an `Error` value if the index does not reference a column or
-    /// the return type is not compatible with the Postgres type.
-    pub fn get_opt<I, T>(&self, idx: I) -> Result<T>
+    /// Returns `None` if the index does not reference a column, `Some(Err(..))`
+    /// if there was an error converting the result value, and `Some(Ok(..))`
+    /// on success.
+    pub fn get_opt<I, T>(&self, idx: I) -> Option<Result<T>>
         where I: RowIndex,
               T: FromSql
     {
         self.get_inner(&idx)
     }
 
-    fn get_inner<I, T>(&self, idx: &I) -> Result<T>
+    fn get_inner<I, T>(&self, idx: &I) -> Option<Result<T>>
         where I: RowIndex,
               T: FromSql
     {
-        let idx = try!(idx.idx(self.stmt).ok_or(Error::InvalidColumn));
+        let idx = match idx.idx(self.stmt) {
+            Some(idx) => idx,
+            None => return None
+        };
+
         let ty = self.stmt.columns()[idx].type_();
         if !<T as FromSql>::accepts(ty) {
-            return Err(Error::WrongType(ty.clone()));
+            return Some(Err(Error::WrongType(ty.clone())));
         }
         let conn = self.stmt.conn().conn.borrow();
-        match self.data[idx] {
+        let value = match self.data[idx] {
             Some(ref data) => FromSql::from_sql(ty, &mut &**data, &SessionInfo::new(&*conn)),
             None => FromSql::from_sql_null(ty, &SessionInfo::new(&*conn)),
-        }
+        };
+        Some(value)
     }
 
     /// Retrieves the specified field as a raw buffer of Postgres data.

tests/test.rs

@@ -495,8 +495,8 @@ fn test_get_named_err() {
     let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
     let result = or_panic!(stmt.query(&[]));
 
-    match result.iter().next().unwrap().get_opt::<&str, i32>("asdf") {
-        Err(Error::InvalidColumn) => {}
+    match result.iter().next().unwrap().get_opt::<_, i32>("asdf") {
+        None => {}
         res => panic!("unexpected result {:?}", res),
     };
 }
@@ -507,8 +507,8 @@ fn test_get_was_null() {
     let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id"));
     let result = or_panic!(stmt.query(&[]));
 
-    match result.iter().next().unwrap().get_opt::<usize, i32>(0) {
-        Err(Error::Conversion(..)) => {}
+    match result.iter().next().unwrap().get_opt::<_, i32>(0) {
+        Some(Err(Error::Conversion(..))) => {}
         res => panic!("unexpected result {:?}", res),
     };
 }
@@ -519,8 +519,8 @@ fn test_get_off_by_one() {
     let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
     let result = or_panic!(stmt.query(&[]));
 
-    match result.iter().next().unwrap().get_opt::<usize, i32>(1) {
-        Err(Error::InvalidColumn) => {}
+    match result.iter().next().unwrap().get_opt::<_, i32>(1) {
+        None => {}
         res => panic!("unexpected result {:?}", res),
     };
 }
@@ -936,9 +936,10 @@ fn test_get_opt_wrong_type() {
     let stmt = conn.prepare("SELECT 1::INT").unwrap();
     let res = stmt.query(&[]).unwrap();
     match res.iter().next().unwrap().get_opt::<_, String>(0) {
-        Ok(_) => panic!("unexpected success"),
-        Err(Error::WrongType(Type::Int4)) => {}
-        Err(e) => panic!("unexpected error {}", e),
+        Some(Ok(_)) => panic!("unexpected success"),
+        Some(Err(Error::WrongType(Type::Int4))) => {}
+        Some(Err(e)) => panic!("unexpected error {}", e),
+        None => panic!("unexpected None"),
     }
 }
 

tests/types/mod.rs

@@ -193,8 +193,8 @@ fn test_pg_database_datname() {
     let result = or_panic!(stmt.query(&[]));
 
     let next = result.iter().next().unwrap();
-    or_panic!(next.get_opt::<usize, String>(0));
-    or_panic!(next.get_opt::<&str, String>("datname"));
+    or_panic!(next.get_opt::<_, String>(0).unwrap());
+    or_panic!(next.get_opt::<_, String>("datname").unwrap());
 }
 
 #[test]