When using .optional(), convert a QueryBuilderError into None

diesel/src/query_builder/update_statement/mod.rs

@@ -11,6 +11,7 @@ use crate::query_builder::where_clause::*;
 use crate::query_dsl::methods::{BoxedDsl, FilterDsl};
 use crate::query_dsl::RunQueryDsl;
 use crate::query_source::Table;
+use crate::result::EmptyChangeset;
 use crate::result::Error::QueryBuilderError;
 use crate::{query_builder::*, QuerySource};
 
@@ -198,9 +199,7 @@ where
 {
     fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
         if self.values.is_noop(out.backend())? {
-            return Err(QueryBuilderError(
-                "There are no changes to save. This query cannot be built".into(),
-            ));
+            return Err(QueryBuilderError(Box::new(EmptyChangeset)));
         }
 
         out.unsafe_to_cache_prepared();

diesel/src/result.rs

@@ -45,6 +45,8 @@ pub enum Error {
     /// An example of when this error could occur is if you are attempting to
     /// construct an update statement with no changes (e.g. all fields on the
     /// struct are `None`).
+    ///
+    /// When using `optional_empty_changeset`, this error is turned into `None`.
     QueryBuilderError(Box<dyn StdError + Send + Sync>),
 
     /// An error occurred deserializing the data being sent to the database.
@@ -268,7 +270,7 @@ pub trait OptionalExtension<T> {
     /// # Example
     ///
     /// ```rust
-    /// use diesel::{QueryResult, NotFound, OptionalExtension};
+    /// use diesel::{QueryResult, NotFound, OptionalExtension, result::Error::QueryBuilderError};
     ///
     /// let result: QueryResult<i32> = Ok(1);
     /// assert_eq!(Ok(Some(1)), result.optional());
@@ -277,6 +279,18 @@ pub trait OptionalExtension<T> {
     /// assert_eq!(Ok(None), result.optional());
     /// ```
     fn optional(self) -> Result<Option<T>, Error>;
+
+    /// By default, Diesel treats an empty update as a `QueryBuilderError`. This method will
+    /// convert that error into `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use diesel::{QueryResult, OptionalExtension, result::Error::QueryBuilderError, result::EmptyChangeset};
+    /// let result: QueryResult<i32> = Err(QueryBuilderError(Box::new(EmptyChangeset)));
+    /// assert_eq!(Ok(None), result.optional_empty_changeset());
+    /// ```
+    fn optional_empty_changeset(self) -> Result<Option<T>, Error>;
 }
 
 impl<T> OptionalExtension<T> for QueryResult<T> {
@@ -287,6 +301,13 @@ impl<T> OptionalExtension<T> for QueryResult<T> {
             Err(e) => Err(e),
         }
     }
+    fn optional_empty_changeset(self) -> Result<Option<T>, Error> {
+        match self {
+            Ok(value) => Ok(Some(value)),
+            Err(Error::QueryBuilderError(e)) if e.is::<EmptyChangeset>() => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
 }
 
 impl From<NulError> for ConnectionError {
@@ -413,3 +434,18 @@ impl fmt::Display for UnexpectedEndOfRow {
 }
 
 impl StdError for UnexpectedEndOfRow {}
+
+/// Expected when an update has no changes to save
+#[derive(Debug, Clone, Copy)]
+pub struct EmptyChangeset;
+
+impl fmt::Display for EmptyChangeset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "There are no changes to save. This query cannot be built"
+        )
+    }
+}
+
+impl StdError for EmptyChangeset {}

diesel_tests/tests/update.rs

@@ -214,7 +214,6 @@ fn sql_syntax_is_correct_when_option_field_comes_mixed_with_non_option() {
 }
 
 #[test]
-#[should_panic(expected = "There are no changes to save.")]
 fn update_with_no_changes() {
     #[derive(AsChangeset)]
     #[diesel(table_name = users)]
@@ -228,10 +227,30 @@ fn update_with_no_changes() {
         name: None,
         hair_color: None,
     };
-    update(users::table)
+    let update_result = update(users::table).set(&changes).execute(connection);
+    assert!(update_result.is_err());
+}
+
+#[test]
+fn update_with_optional_empty_changeset() {
+    #[derive(AsChangeset)]
+    #[diesel(table_name = users)]
+    struct Changes {
+        name: Option<String>,
+        hair_color: Option<String>,
+    }
+
+    let connection = &mut connection();
+    let changes = Changes {
+        name: None,
+        hair_color: None,
+    };
+    let update_result = update(users::table)
         .set(&changes)
         .execute(connection)
+        .optional_empty_changeset()
         .unwrap();
+    assert_eq!(None, update_result);
 }
 
 #[test]