Unify error types for postgres

Author: sfackler

postgres/src/error.rs

@@ -7,60 +7,106 @@ use std::error;
 // FIXME
 pub use postgres_shared::error::*;
 
-/// An error encountered when communicating with the Postgres server.
 #[derive(Debug)]
-pub enum Error {
-    /// An error reported by the Postgres server.
-    Db(Box<DbError>),
-    /// An error communicating with the Postgres server.
+pub(crate) enum ErrorKind {
+    ConnectParams(Box<error::Error + Sync + Send>),
+    Tls(Box<error::Error + Sync + Send>),
+    Db(DbError),
     Io(io::Error),
-    /// An error converting between Postgres and Rust types.
     Conversion(Box<error::Error + Sync + Send>),
 }
 
+/// An error communicating with the Postgres server.
+#[derive(Debug)]
+pub struct Error(pub(crate) Box<ErrorKind>);
+
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.write_str(error::Error::description(self))?;
-        match *self {
-            Error::Db(ref err) => write!(fmt, ": {}", err),
-            Error::Io(ref err) => write!(fmt, ": {}", err),
-            Error::Conversion(ref err) => write!(fmt, ": {}", err),
+        match *self.0 {
+            ErrorKind::ConnectParams(ref err) => write!(fmt, ": {}", err),
+            ErrorKind::Tls(ref err) => write!(fmt, ": {}", err),
+            ErrorKind::Db(ref err) => write!(fmt, ": {}", err),
+            ErrorKind::Io(ref err) => write!(fmt, ": {}", err),
+            ErrorKind::Conversion(ref err) => write!(fmt, ": {}", err),
         }
     }
 }
 
 impl error::Error for Error {
     fn description(&self) -> &str {
-        match *self {
-            Error::Db(_) => "Error reported by Postgres",
-            Error::Io(_) => "Error communicating with the server",
-            Error::Conversion(_) => "Error converting between Postgres and Rust types",
+        match *self.0 {
+            ErrorKind::ConnectParams(_) => "invalid connection parameters",
+            ErrorKind::Tls(_) => "TLS handshake error",
+            ErrorKind::Db(_) => "database error",
+            ErrorKind::Io(_) => "IO error",
+            ErrorKind::Conversion(_) => "type conversion error",
         }
     }
 
     fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Db(ref err) => Some(&**err),
-            Error::Io(ref err) => Some(err),
-            Error::Conversion(ref err) => Some(&**err),
+        match *self.0 {
+            ErrorKind::ConnectParams(ref err) => Some(&**err),
+            ErrorKind::Tls(ref err) => Some(&**err),
+            ErrorKind::Db(ref err) => Some(err),
+            ErrorKind::Io(ref err) => Some(err),
+            ErrorKind::Conversion(ref err) => Some(&**err),
         }
     }
 }
 
-impl From<DbError> for Error {
-    fn from(err: DbError) -> Error {
-        Error::Db(Box::new(err))
+impl Error {
+    /// Returns the SQLSTATE error code associated with this error if it is a DB
+    /// error.
+    pub fn code(&self) -> Option<&SqlState> {
+        self.as_db().map(|e| &e.code)
+    }
+
+    /// Returns the inner error if this is a connection parameter error.
+    pub fn as_connection(&self) -> Option<&(error::Error + 'static + Sync + Send)> {
+        match *self.0 {
+            ErrorKind::ConnectParams(ref err) => Some(&**err),
+            _ => None,
+        }
+    }
+
+    /// Returns the `DbError` associated with this error if it is a DB error.
+    pub fn as_db(&self) -> Option<&DbError> {
+        match *self.0 {
+            ErrorKind::Db(ref err) => Some(err),
+            _ => None
+        }
+    }
+
+    /// Returns the inner error if this is a conversion error.
+    pub fn as_conversion(&self) -> Option<&(error::Error + 'static + Sync + Send)> {
+        match *self.0 {
+            ErrorKind::Conversion(ref err) => Some(&**err),
+            _ => None,
+        }
+    }
+
+    /// Returns the inner `io::Error` associated with this error if it is an IO
+    /// error.
+    pub fn as_io(&self) -> Option<&io::Error> {
+        match *self.0 {
+            ErrorKind::Io(ref err) => Some(err),
+            _ => None,
+        }
     }
 }
 
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Error {
-        Error::Io(err)
+        Error(Box::new(ErrorKind::Io(err)))
     }
 }
 
 impl From<Error> for io::Error {
     fn from(err: Error) -> io::Error {
-        io::Error::new(io::ErrorKind::Other, err)
+        match *err.0 {
+            ErrorKind::Io(e) => e,
+            _ => io::Error::new(io::ErrorKind::Other, err),
+        }
     }
 }