diff --git a/src/backend.rs b/src/backend.rs
index 389432b..30ae0f1 100644
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -42,111 +42,93 @@ impl Backend {
             for action in action_receiver {
                 match action {
                     UpdatePerson(person, sender) => {
-                        db.update_person(person);
                         sender
-                            .send(Ok(()))
+                            .send(db.update_person(person))
                             .expect("Failed to send result from database thread!");
                     }
                     GetPerson(id, sender) => {
-                        let person = db.get_person(id);
                         sender
-                            .send(person)
+                            .send(db.get_person(id))
                             .expect("Failed to send result from database thread!");
                     }
                     DeletePerson(id, sender) => {
-                        db.delete_person(id);
                         sender
-                            .send(Ok(()))
+                            .send(db.delete_person(id))
                             .expect("Failed to send result from database thread!");
                     }
                     GetPersons(sender) => {
-                        let persons = db.get_persons();
                         sender
-                            .send(persons)
+                            .send(db.get_persons())
                             .expect("Failed to send result from database thread!");
                     }
                     UpdateInstrument(instrument, sender) => {
-                        db.update_instrument(instrument);
                         sender
-                            .send(Ok(()))
+                            .send(db.update_instrument(instrument))
                             .expect("Failed to send result from database thread!");
                     }
                     GetInstrument(id, sender) => {
-                        let instrument = db.get_instrument(id);
                         sender
-                            .send(instrument)
+                            .send(db.get_instrument(id))
                             .expect("Failed to send result from database thread!");
                     }
                     DeleteInstrument(id, sender) => {
-                        db.delete_instrument(id);
                         sender
-                            .send(Ok(()))
+                            .send(db.delete_instrument(id))
                             .expect("Failed to send result from database thread!");
                     }
                     GetInstruments(sender) => {
-                        let instruments = db.get_instruments();
                         sender
-                            .send(instruments)
+                            .send(db.get_instruments())
                             .expect("Failed to send result from database thread!");
                     }
                     UpdateWork(work, sender) => {
-                        db.update_work(work);
                         sender
-                            .send(Ok(()))
+                            .send(db.update_work(work))
                             .expect("Failed to send result from database thread!");
                     }
                     GetWorkDescriptions(id, sender) => {
-                        let works = db.get_work_descriptions(id);
                         sender
-                            .send(works)
+                            .send(db.get_work_descriptions(id))
                             .expect("Failed to send result from database thread!");
                     }
                     UpdateEnsemble(ensemble, sender) => {
-                        db.update_ensemble(ensemble);
                         sender
-                            .send(Ok(()))
+                            .send(db.update_ensemble(ensemble))
                             .expect("Failed to send result from database thread!");
                     }
                     GetEnsemble(id, sender) => {
-                        let ensemble = db.get_ensemble(id);
                         sender
-                            .send(ensemble)
+                            .send(db.get_ensemble(id))
                             .expect("Failed to send result from database thread!");
                     }
                     DeleteEnsemble(id, sender) => {
-                        db.delete_ensemble(id);
                         sender
-                            .send(Ok(()))
+                            .send(db.delete_ensemble(id))
                             .expect("Failed to send result from database thread!");
                     }
                     GetEnsembles(sender) => {
-                        let ensembles = db.get_ensembles();
                         sender
-                            .send(ensembles)
+                            .send(db.get_ensembles())
                             .expect("Failed to send result from database thread!");
                     }
                     UpdateRecording(recording, sender) => {
-                        db.update_recording(recording);
                         sender
-                            .send(Ok(()))
+                            .send(db.update_recording(recording))
                             .expect("Failed to send result from database thread!");
                     }
                     GetRecordingsForPerson(id, sender) => {
-                        let recordings = db.get_recordings_for_person(id);
                         sender
-                            .send(recordings)
+                            .send(db.get_recordings_for_person(id))
                             .expect("Failed to send result from database thread!");
                     }
                     GetRecordingsForEnsemble(id, sender) => {
-                        let recordings = db.get_recordings_for_ensemble(id);
                         sender
-                            .send(recordings)
+                            .send(db.get_recordings_for_ensemble(id))
                             .expect("Failed to send result from database thread!");
                     }
                     GetRecordingsForWork(id, sender) => {
-                        let recordings = db.get_recordings_for_work(id);
                         sender
-                            .send(recordings)
+                            .send(db.get_recordings_for_work(id))
                             .expect("Failed to send result from database thread!");
                     }
                 }
@@ -160,94 +142,95 @@ impl Backend {
 
     pub async fn update_person(&self, person: Person) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(UpdatePerson(person, sender));
+        self.action_sender.send(UpdatePerson(person, sender))?;
         receiver.await?
     }
 
     pub async fn get_person(&self, id: i64) -> Result<Person> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetPerson(id, sender));
+        self.action_sender.send(GetPerson(id, sender))?;
         receiver.await?
     }
 
     pub async fn delete_person(&self, id: i64) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(DeletePerson(id, sender));
+        self.action_sender.send(DeletePerson(id, sender))?;
         receiver.await?
     }
 
     pub async fn get_persons(&self) -> Result<Vec<Person>> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetPersons(sender));
+        self.action_sender.send(GetPersons(sender))?;
         receiver.await?
     }
 
     pub async fn update_instrument(&self, instrument: Instrument) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(UpdateInstrument(instrument, sender));
+            .send(UpdateInstrument(instrument, sender))?;
         receiver.await?
     }
 
     pub async fn get_instrument(&self, id: i64) -> Result<Instrument> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetInstrument(id, sender));
+        self.action_sender.send(GetInstrument(id, sender))?;
         receiver.await?
     }
 
     pub async fn delete_instrument(&self, id: i64) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(DeleteInstrument(id, sender));
+        self.action_sender.send(DeleteInstrument(id, sender))?;
         receiver.await?
     }
 
     pub async fn get_instruments(&self) -> Result<Vec<Instrument>> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetInstruments(sender));
+        self.action_sender.send(GetInstruments(sender))?;
         receiver.await?
     }
 
     pub async fn update_work(&self, work_insertion: WorkInsertion) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(UpdateWork(work_insertion, sender));
+        self.action_sender
+            .send(UpdateWork(work_insertion, sender))?;
         receiver.await?
     }
 
     pub async fn get_work_descriptions(&self, person_id: i64) -> Result<Vec<WorkDescription>> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(GetWorkDescriptions(person_id, sender));
+            .send(GetWorkDescriptions(person_id, sender))?;
         receiver.await?
     }
 
     pub async fn update_ensemble(&self, ensemble: Ensemble) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(UpdateEnsemble(ensemble, sender));
+        self.action_sender.send(UpdateEnsemble(ensemble, sender))?;
         receiver.await?
     }
 
     pub async fn get_ensemble(&self, id: i64) -> Result<Ensemble> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetEnsemble(id, sender));
+        self.action_sender.send(GetEnsemble(id, sender))?;
         receiver.await?
     }
 
     pub async fn delete_ensemble(&self, id: i64) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(DeleteEnsemble(id, sender));
+        self.action_sender.send(DeleteEnsemble(id, sender))?;
         receiver.await?
     }
 
     pub async fn get_ensembles(&self) -> Result<Vec<Ensemble>> {
         let (sender, receiver) = oneshot::channel();
-        self.action_sender.send(GetEnsembles(sender));
+        self.action_sender.send(GetEnsembles(sender))?;
         receiver.await?
     }
 
     pub async fn update_recording(&self, recording_insertion: RecordingInsertion) -> Result<()> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(UpdateRecording(recording_insertion, sender));
+            .send(UpdateRecording(recording_insertion, sender))?;
         receiver.await?
     }
 
@@ -257,7 +240,7 @@ impl Backend {
     ) -> Result<Vec<RecordingDescription>> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(GetRecordingsForPerson(person_id, sender));
+            .send(GetRecordingsForPerson(person_id, sender))?;
         receiver.await?
     }
 
@@ -267,14 +250,14 @@ impl Backend {
     ) -> Result<Vec<RecordingDescription>> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(GetRecordingsForEnsemble(ensemble_id, sender));
+            .send(GetRecordingsForEnsemble(ensemble_id, sender))?;
         receiver.await?
     }
 
     pub async fn get_recordings_for_work(&self, work_id: i64) -> Result<Vec<RecordingDescription>> {
         let (sender, receiver) = oneshot::channel();
         self.action_sender
-            .send(GetRecordingsForWork(work_id, sender));
+            .send(GetRecordingsForWork(work_id, sender))?;
         receiver.await?
     }
 }
diff --git a/src/database/database.rs b/src/database/database.rs
index 85ba0b8..5247312 100644
--- a/src/database/database.rs
+++ b/src/database/database.rs
@@ -1,7 +1,7 @@
 use super::models::*;
 use super::schema::*;
 use super::tables::*;
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Error, Result};
 use diesel::prelude::*;
 
 embed_migrations!();
@@ -84,8 +84,8 @@ impl Database {
         let id = work_insertion.work.id;
 
         self.defer_foreign_keys();
-        self.c.transaction(|| {
-            self.delete_work(id);
+        self.c.transaction::<(), Error, _>(|| {
+            self.delete_work(id)?;
 
             diesel::insert_into(works::table)
                 .values(work_insertion.work)
@@ -125,7 +125,7 @@ impl Database {
                     .execute(&self.c)?;
             }
 
-            diesel::result::QueryResult::Ok(())
+            Ok(())
         })?;
 
         Ok(())
@@ -267,8 +267,8 @@ impl Database {
         let id = recording_insertion.recording.id;
 
         self.defer_foreign_keys();
-        self.c.transaction(|| {
-            self.delete_recording(id);
+        self.c.transaction::<(), Error, _>(|| {
+            self.delete_recording(id)?;
 
             diesel::insert_into(recordings::table)
                 .values(recording_insertion.recording)
@@ -280,7 +280,7 @@ impl Database {
                     .execute(&self.c)?;
             }
 
-            diesel::result::QueryResult::Ok(())
+            Ok(())
         })?;
 
         Ok(())
diff --git a/src/window.rs b/src/window.rs
index 62dbf67..c0d36d3 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -1,7 +1,6 @@
 use super::backend::Backend;
 use super::database::*;
 use super::dialogs::*;
-use futures::prelude::*;
 use gio::prelude::*;
 use glib::clone;
 use gtk::prelude::*;
@@ -603,7 +602,7 @@ impl Window {
                     .set_visible_child_name("work_details_screen");
                 self.leaflet.set_visible_child_name("content");
             }
-            WorkScreen(poe, work, recordings, search) => {
+            WorkScreen(poe, _, recordings, search) => {
                 for child in self.work_details_recording_list.get_children() {
                     self.work_details_recording_list.remove(&child);
                 }
@@ -664,7 +663,7 @@ impl Window {
                     .set_visible_child_name("work_details_screen");
                 self.leaflet.set_visible_child_name("content");
             }
-            RecordingScreenLoading(poe, recording) => {
+            RecordingScreenLoading(_, recording) => {
                 self.recording_details_header
                     .set_title(Some(&recording.work.get_title()));
                 self.recording_details_header