Add DatabaseErrorKind::ReadOnlyTransaction

This is an error that applications are likely to want to handle. A
database may be read only during maintenance, or for brief periods after
failing over to a hot replica.

Applications designed to handle this may wish to transform this error
into a user visible HTTP 503 response, or skip certain optional writes.
By providing this error variant, we allow them to gracefully do so,
without having to resort to parsing error messages as was needed in
rust-lang/crates.io#1670

Author: sgrif

CHANGELOG.md

@@ -10,6 +10,9 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 
 * `NonAggregate` can now be derived for simple cases.
 
+* Added `DatabaseErrorKind::ReadOnlyTransaction` to allow applications to
+  handle errors caused by writing when only allowed to read.
+
 ### Removed
 
 * All previously deprecated items have been removed.

diesel/src/mysql/connection/stmt/mod.rs

@@ -147,6 +147,7 @@ impl Statement {
         match last_error_number {
             1062 | 1586 | 1859 => DatabaseErrorKind::UniqueViolation,
             1216 | 1217 | 1451 | 1452 | 1830 | 1834 => DatabaseErrorKind::ForeignKeyViolation,
+            1792 => DatabaseErrorKind::ReadOnlyTransaction,
             _ => DatabaseErrorKind::__Unknown,
         }
     }

diesel/src/pg/connection/result.rs

@@ -34,12 +34,9 @@ impl PgResult {
                 let error_kind =
                     match get_result_field(internal_result.as_ptr(), ResultField::SqlState) {
                         Some(error_codes::UNIQUE_VIOLATION) => DatabaseErrorKind::UniqueViolation,
-                        Some(error_codes::FOREIGN_KEY_VIOLATION) => {
-                            DatabaseErrorKind::ForeignKeyViolation
-                        }
-                        Some(error_codes::SERIALIZATION_FAILURE) => {
-                            DatabaseErrorKind::SerializationFailure
-                        }
+                        Some(error_codes::FOREIGN_KEY_VIOLATION) => DatabaseErrorKind::ForeignKeyViolation,
+                        Some(error_codes::SERIALIZATION_FAILURE) => DatabaseErrorKind::SerializationFailure,
+                        Some(error_codes::READ_ONLY_TRANSACTION) => DatabaseErrorKind::ReadOnlyTransaction,
                         _ => DatabaseErrorKind::__Unknown,
                     };
                 let error_information = Box::new(PgErrorInformation(internal_result));
@@ -167,4 +164,5 @@ mod error_codes {
     pub const UNIQUE_VIOLATION: &str = "23505";
     pub const FOREIGN_KEY_VIOLATION: &str = "23503";
     pub const SERIALIZATION_FAILURE: &str = "40001";
+    pub const READ_ONLY_TRANSACTION: &str = "25006";
 }

diesel/src/result.rs

@@ -106,6 +106,13 @@ pub enum DatabaseErrorKind {
     /// transaction isolation levels for other backends.
     SerializationFailure,
 
+    /// The command could not be completed because the transaction was read
+    /// only.
+    ///
+    /// This error will also be returned for `SELECT` statements which attempted
+    /// to lock the rows.
+    ReadOnlyTransaction,
+
     #[doc(hidden)]
     __Unknown, // Match against _ instead, more variants may be added in the future
 }

diesel_tests/tests/errors.rs

@@ -176,3 +176,19 @@ fn isolation_errors_are_detected() {
     assert_matches!(results[0], Ok(_));
     assert_matches!(results[1], Err(DatabaseError(SerializationFailure, _)));
 }
+
+#[test]
+#[cfg(not(feature = "sqlite"))]
+fn read_only_errors_are_detected() {
+    use diesel::result::DatabaseErrorKind::ReadOnlyTransaction;
+
+    let conn = connection_without_transaction();
+    conn.execute("START TRANSACTION READ ONLY")
+        .unwrap();
+
+    let result = users::table
+        .for_update()
+        .load::<User>(&conn);
+
+    assert_matches!(result, Err(DatabaseError(ReadOnlyTransaction, _)));
+}