diff --git a/crates/api/src/comment/distinguish.rs b/crates/api/src/comment/distinguish.rs
index 17f45bfd4..d89f0be8c 100644
--- a/crates/api/src/comment/distinguish.rs
+++ b/crates/api/src/comment/distinguish.rs
@@ -22,18 +22,18 @@ impl Perform for DistinguishComment {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let comment_id = data.comment_id;
-    let orig_comment = CommentView::read(context.pool(), comment_id, None).await?;
+    let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_comment.community.id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
     // Verify that only a mod or admin can distinguish a comment
     is_mod_or_admin(
-      context.pool(),
+      &mut context.pool(),
       local_user_view.person.id,
       orig_comment.community.id,
     )
@@ -44,13 +44,13 @@ impl Perform for DistinguishComment {
     let form = CommentUpdateForm::builder()
       .distinguished(Some(data.distinguished))
       .build();
-    Comment::update(context.pool(), comment_id, &form)
+    Comment::update(&mut context.pool(), comment_id, &form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 
     let comment_id = data.comment_id;
     let person_id = local_user_view.person.id;
-    let comment_view = CommentView::read(context.pool(), comment_id, Some(person_id)).await?;
+    let comment_view = CommentView::read(&mut context.pool(), comment_id, Some(person_id)).await?;
 
     Ok(CommentResponse {
       comment_view,
diff --git a/crates/api/src/comment/like.rs b/crates/api/src/comment/like.rs
index 6c4bdebc7..aab611383 100644
--- a/crates/api/src/comment/like.rs
+++ b/crates/api/src/comment/like.rs
@@ -25,7 +25,7 @@ impl Perform for CreateCommentLike {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
     let data: &CreateCommentLike = self;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let mut recipient_ids = Vec::<LocalUserId>::new();
@@ -34,20 +34,22 @@ impl Perform for CreateCommentLike {
     check_downvotes_enabled(data.score, &local_site)?;
 
     let comment_id = data.comment_id;
-    let orig_comment = CommentView::read(context.pool(), comment_id, None).await?;
+    let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_comment.community.id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
     // Add parent poster or commenter to recipients
-    let comment_reply = CommentReply::read_by_comment(context.pool(), comment_id).await;
+    let comment_reply = CommentReply::read_by_comment(&mut context.pool(), comment_id).await;
     if let Ok(reply) = comment_reply {
       let recipient_id = reply.recipient_id;
-      if let Ok(local_recipient) = LocalUserView::read_person(context.pool(), recipient_id).await {
+      if let Ok(local_recipient) =
+        LocalUserView::read_person(&mut context.pool(), recipient_id).await
+      {
         recipient_ids.push(local_recipient.local_user.id);
       }
     }
@@ -62,12 +64,12 @@ impl Perform for CreateCommentLike {
     // Remove any likes first
     let person_id = local_user_view.person.id;
 
-    CommentLike::remove(context.pool(), person_id, comment_id).await?;
+    CommentLike::remove(&mut context.pool(), person_id, comment_id).await?;
 
     // Only add the like if the score isnt 0
     let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
     if do_add {
-      CommentLike::like(context.pool(), &like_form)
+      CommentLike::like(&mut context.pool(), &like_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?;
     }
diff --git a/crates/api/src/comment/save.rs b/crates/api/src/comment/save.rs
index 70c9745f8..27a919bde 100644
--- a/crates/api/src/comment/save.rs
+++ b/crates/api/src/comment/save.rs
@@ -27,18 +27,18 @@ impl Perform for SaveComment {
     };
 
     if data.save {
-      CommentSaved::save(context.pool(), &comment_saved_form)
+      CommentSaved::save(&mut context.pool(), &comment_saved_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
     } else {
-      CommentSaved::unsave(context.pool(), &comment_saved_form)
+      CommentSaved::unsave(&mut context.pool(), &comment_saved_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
     }
 
     let comment_id = data.comment_id;
     let person_id = local_user_view.person.id;
-    let comment_view = CommentView::read(context.pool(), comment_id, Some(person_id)).await?;
+    let comment_view = CommentView::read(&mut context.pool(), comment_id, Some(person_id)).await?;
 
     Ok(CommentResponse {
       comment_view,
diff --git a/crates/api/src/comment_report/create.rs b/crates/api/src/comment_report/create.rs
index 8ef975786..4d2c09be2 100644
--- a/crates/api/src/comment_report/create.rs
+++ b/crates/api/src/comment_report/create.rs
@@ -27,16 +27,16 @@ impl Perform for CreateCommentReport {
   ) -> Result<CommentReportResponse, LemmyError> {
     let data: &CreateCommentReport = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let reason = self.reason.trim();
     check_report_reason(reason, &local_site)?;
 
     let person_id = local_user_view.person.id;
     let comment_id = data.comment_id;
-    let comment_view = CommentView::read(context.pool(), comment_id, None).await?;
+    let comment_view = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
-    check_community_ban(person_id, comment_view.community.id, context.pool()).await?;
+    check_community_ban(person_id, comment_view.community.id, &mut context.pool()).await?;
 
     let report_form = CommentReportForm {
       creator_id: person_id,
@@ -45,18 +45,19 @@ impl Perform for CreateCommentReport {
       reason: reason.to_owned(),
     };
 
-    let report = CommentReport::report(context.pool(), &report_form)
+    let report = CommentReport::report(&mut context.pool(), &report_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
 
-    let comment_report_view = CommentReportView::read(context.pool(), report.id, person_id).await?;
+    let comment_report_view =
+      CommentReportView::read(&mut context.pool(), report.id, person_id).await?;
 
     // Email the admins
     if local_site.reports_email_admins {
       send_new_report_email_to_admins(
         &comment_report_view.creator.name,
         &comment_report_view.comment_creator.name,
-        context.pool(),
+        &mut context.pool(),
         context.settings(),
       )
       .await?;
diff --git a/crates/api/src/comment_report/list.rs b/crates/api/src/comment_report/list.rs
index d8a4221db..baa1bf45f 100644
--- a/crates/api/src/comment_report/list.rs
+++ b/crates/api/src/comment_report/list.rs
@@ -30,7 +30,7 @@ impl Perform for ListCommentReports {
     let page = data.page;
     let limit = data.limit;
     let comment_reports = CommentReportQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .my_person_id(person_id)
       .admin(admin)
       .community_id(community_id)
diff --git a/crates/api/src/comment_report/resolve.rs b/crates/api/src/comment_report/resolve.rs
index 5f1ae97dd..4397b015c 100644
--- a/crates/api/src/comment_report/resolve.rs
+++ b/crates/api/src/comment_report/resolve.rs
@@ -24,23 +24,24 @@ impl Perform for ResolveCommentReport {
 
     let report_id = data.report_id;
     let person_id = local_user_view.person.id;
-    let report = CommentReportView::read(context.pool(), report_id, person_id).await?;
+    let report = CommentReportView::read(&mut context.pool(), report_id, person_id).await?;
 
     let person_id = local_user_view.person.id;
-    is_mod_or_admin(context.pool(), person_id, report.community.id).await?;
+    is_mod_or_admin(&mut context.pool(), person_id, report.community.id).await?;
 
     if data.resolved {
-      CommentReport::resolve(context.pool(), report_id, person_id)
+      CommentReport::resolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     } else {
-      CommentReport::unresolve(context.pool(), report_id, person_id)
+      CommentReport::unresolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     }
 
     let report_id = data.report_id;
-    let comment_report_view = CommentReportView::read(context.pool(), report_id, person_id).await?;
+    let comment_report_view =
+      CommentReportView::read(&mut context.pool(), report_id, person_id).await?;
 
     Ok(CommentReportResponse {
       comment_report_view,
diff --git a/crates/api/src/community/add_mod.rs b/crates/api/src/community/add_mod.rs
index a7afd952d..9b3800dcb 100644
--- a/crates/api/src/community/add_mod.rs
+++ b/crates/api/src/community/add_mod.rs
@@ -30,8 +30,8 @@ impl Perform for AddModToCommunity {
     let community_id = data.community_id;
 
     // Verify that only mods or admins can add mod
-    is_mod_or_admin(context.pool(), local_user_view.person.id, community_id).await?;
-    let community = Community::read(context.pool(), community_id).await?;
+    is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
     if local_user_view.person.admin && !community.local {
       return Err(LemmyError::from_message("not_a_moderator"));
     }
@@ -42,11 +42,11 @@ impl Perform for AddModToCommunity {
       person_id: data.person_id,
     };
     if data.added {
-      CommunityModerator::join(context.pool(), &community_moderator_form)
+      CommunityModerator::join(&mut context.pool(), &community_moderator_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
     } else {
-      CommunityModerator::leave(context.pool(), &community_moderator_form)
+      CommunityModerator::leave(&mut context.pool(), &community_moderator_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
     }
@@ -59,12 +59,13 @@ impl Perform for AddModToCommunity {
       removed: Some(!data.added),
     };
 
-    ModAddCommunity::create(context.pool(), &form).await?;
+    ModAddCommunity::create(&mut context.pool(), &form).await?;
 
     // Note: in case a remote mod is added, this returns the old moderators list, it will only get
     //       updated once we receive an activity from the community (like `Announce/Add/Moderator`)
     let community_id = data.community_id;
-    let moderators = CommunityModeratorView::for_community(context.pool(), community_id).await?;
+    let moderators =
+      CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
 
     Ok(AddModToCommunityResponse { moderators })
   }
diff --git a/crates/api/src/community/ban.rs b/crates/api/src/community/ban.rs
index 330c2c56d..504ed1728 100644
--- a/crates/api/src/community/ban.rs
+++ b/crates/api/src/community/ban.rs
@@ -41,7 +41,7 @@ impl Perform for BanFromCommunity {
     let expires = data.expires.map(naive_from_unix);
 
     // Verify that only mods or admins can ban
-    is_mod_or_admin(context.pool(), local_user_view.person.id, community_id).await?;
+    is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id).await?;
     is_valid_body_field(&data.reason, false)?;
 
     let community_user_ban_form = CommunityPersonBanForm {
@@ -51,7 +51,7 @@ impl Perform for BanFromCommunity {
     };
 
     if data.ban {
-      CommunityPersonBan::ban(context.pool(), &community_user_ban_form)
+      CommunityPersonBan::ban(&mut context.pool(), &community_user_ban_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
 
@@ -62,18 +62,18 @@ impl Perform for BanFromCommunity {
         pending: false,
       };
 
-      CommunityFollower::unfollow(context.pool(), &community_follower_form)
+      CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
         .await
         .ok();
     } else {
-      CommunityPersonBan::unban(context.pool(), &community_user_ban_form)
+      CommunityPersonBan::unban(&mut context.pool(), &community_user_ban_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
     }
 
     // Remove/Restore their data if that's desired
     if remove_data {
-      remove_user_data_in_community(community_id, banned_person_id, context.pool()).await?;
+      remove_user_data_in_community(community_id, banned_person_id, &mut context.pool()).await?;
     }
 
     // Mod tables
@@ -86,10 +86,10 @@ impl Perform for BanFromCommunity {
       expires,
     };
 
-    ModBanFromCommunity::create(context.pool(), &form).await?;
+    ModBanFromCommunity::create(&mut context.pool(), &form).await?;
 
     let person_id = data.person_id;
-    let person_view = PersonView::read(context.pool(), person_id).await?;
+    let person_view = PersonView::read(&mut context.pool(), person_id).await?;
 
     Ok(BanFromCommunityResponse {
       person_view,
diff --git a/crates/api/src/community/block.rs b/crates/api/src/community/block.rs
index fe3fb6e07..8a0379312 100644
--- a/crates/api/src/community/block.rs
+++ b/crates/api/src/community/block.rs
@@ -35,7 +35,7 @@ impl Perform for BlockCommunity {
     };
 
     if data.block {
-      CommunityBlock::block(context.pool(), &community_block_form)
+      CommunityBlock::block(&mut context.pool(), &community_block_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
 
@@ -46,17 +46,17 @@ impl Perform for BlockCommunity {
         pending: false,
       };
 
-      CommunityFollower::unfollow(context.pool(), &community_follower_form)
+      CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
         .await
         .ok();
     } else {
-      CommunityBlock::unblock(context.pool(), &community_block_form)
+      CommunityBlock::unblock(&mut context.pool(), &community_block_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
     }
 
     let community_view =
-      CommunityView::read(context.pool(), community_id, Some(person_id), None).await?;
+      CommunityView::read(&mut context.pool(), community_id, Some(person_id), None).await?;
 
     Ok(BlockCommunityResponse {
       blocked: data.block,
diff --git a/crates/api/src/community/follow.rs b/crates/api/src/community/follow.rs
index 39feeff25..f672ff20a 100644
--- a/crates/api/src/community/follow.rs
+++ b/crates/api/src/community/follow.rs
@@ -25,7 +25,7 @@ impl Perform for FollowCommunity {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let community_id = data.community_id;
-    let community = Community::read(context.pool(), community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
     let mut community_follower_form = CommunityFollowerForm {
       community_id: data.community_id,
       person_id: local_user_view.person.id,
@@ -34,22 +34,22 @@ impl Perform for FollowCommunity {
 
     if data.follow {
       if community.local {
-        check_community_ban(local_user_view.person.id, community_id, context.pool()).await?;
-        check_community_deleted_or_removed(community_id, context.pool()).await?;
+        check_community_ban(local_user_view.person.id, community_id, &mut context.pool()).await?;
+        check_community_deleted_or_removed(community_id, &mut context.pool()).await?;
 
-        CommunityFollower::follow(context.pool(), &community_follower_form)
+        CommunityFollower::follow(&mut context.pool(), &community_follower_form)
           .await
           .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
       } else {
         // Mark as pending, the actual federation activity is sent via `SendActivity` handler
         community_follower_form.pending = true;
-        CommunityFollower::follow(context.pool(), &community_follower_form)
+        CommunityFollower::follow(&mut context.pool(), &community_follower_form)
           .await
           .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
       }
     }
     if !data.follow {
-      CommunityFollower::unfollow(context.pool(), &community_follower_form)
+      CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
     }
@@ -57,8 +57,8 @@ impl Perform for FollowCommunity {
     let community_id = data.community_id;
     let person_id = local_user_view.person.id;
     let community_view =
-      CommunityView::read(context.pool(), community_id, Some(person_id), None).await?;
-    let discussion_languages = CommunityLanguage::read(context.pool(), community_id).await?;
+      CommunityView::read(&mut context.pool(), community_id, Some(person_id), None).await?;
+    let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
 
     Ok(Self::Response {
       community_view,
diff --git a/crates/api/src/community/hide.rs b/crates/api/src/community/hide.rs
index f8d4b1fd7..27a407d8a 100644
--- a/crates/api/src/community/hide.rs
+++ b/crates/api/src/community/hide.rs
@@ -39,11 +39,11 @@ impl Perform for HideCommunity {
     };
 
     let community_id = data.community_id;
-    Community::update(context.pool(), community_id, &community_form)
+    Community::update(&mut context.pool(), community_id, &community_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community_hidden_status"))?;
 
-    ModHideCommunity::create(context.pool(), &mod_hide_community_form).await?;
+    ModHideCommunity::create(&mut context.pool(), &mod_hide_community_form).await?;
 
     build_community_response(context, local_user_view, community_id).await
   }
diff --git a/crates/api/src/community/transfer.rs b/crates/api/src/community/transfer.rs
index 10ba1c4fa..fa163ebae 100644
--- a/crates/api/src/community/transfer.rs
+++ b/crates/api/src/community/transfer.rs
@@ -33,7 +33,7 @@ impl Perform for TransferCommunity {
     // Fetch the community mods
     let community_id = data.community_id;
     let mut community_mods =
-      CommunityModeratorView::for_community(context.pool(), community_id).await?;
+      CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
 
     // Make sure transferrer is either the top community mod, or an admin
     if !(is_top_mod(&local_user_view, &community_mods).is_ok()
@@ -54,7 +54,7 @@ impl Perform for TransferCommunity {
     // Delete all the mods
     let community_id = data.community_id;
 
-    CommunityModerator::delete_for_community(context.pool(), community_id).await?;
+    CommunityModerator::delete_for_community(&mut context.pool(), community_id).await?;
 
     // TODO: this should probably be a bulk operation
     // Re-add the mods, in the new order
@@ -64,7 +64,7 @@ impl Perform for TransferCommunity {
         person_id: cmod.moderator.id,
       };
 
-      CommunityModerator::join(context.pool(), &community_moderator_form)
+      CommunityModerator::join(&mut context.pool(), &community_moderator_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
     }
@@ -76,16 +76,17 @@ impl Perform for TransferCommunity {
       community_id: data.community_id,
     };
 
-    ModTransferCommunity::create(context.pool(), &form).await?;
+    ModTransferCommunity::create(&mut context.pool(), &form).await?;
 
     let community_id = data.community_id;
     let person_id = local_user_view.person.id;
-    let community_view = CommunityView::read(context.pool(), community_id, Some(person_id), None)
-      .await
-      .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
+    let community_view =
+      CommunityView::read(&mut context.pool(), community_id, Some(person_id), None)
+        .await
+        .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
 
     let community_id = data.community_id;
-    let moderators = CommunityModeratorView::for_community(context.pool(), community_id)
+    let moderators = CommunityModeratorView::for_community(&mut context.pool(), community_id)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
 
diff --git a/crates/api/src/lib.rs b/crates/api/src/lib.rs
index 7ac3cec72..fbba2d060 100644
--- a/crates/api/src/lib.rs
+++ b/crates/api/src/lib.rs
@@ -94,7 +94,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_should_not_validate_user_token_after_password_change() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let secret = Secret::init(pool).await.unwrap();
     let settings = &SETTINGS.to_owned();
 
diff --git a/crates/api/src/local_user/add_admin.rs b/crates/api/src/local_user/add_admin.rs
index 0d2db3771..3aef53549 100644
--- a/crates/api/src/local_user/add_admin.rs
+++ b/crates/api/src/local_user/add_admin.rs
@@ -30,7 +30,7 @@ impl Perform for AddAdmin {
     let added = data.added;
     let added_person_id = data.person_id;
     let added_admin = Person::update(
-      context.pool(),
+      &mut context.pool(),
       added_person_id,
       &PersonUpdateForm::builder().admin(Some(added)).build(),
     )
@@ -44,9 +44,9 @@ impl Perform for AddAdmin {
       removed: Some(!data.added),
     };
 
-    ModAdd::create(context.pool(), &form).await?;
+    ModAdd::create(&mut context.pool(), &form).await?;
 
-    let admins = PersonView::admins(context.pool()).await?;
+    let admins = PersonView::admins(&mut context.pool()).await?;
 
     Ok(AddAdminResponse { admins })
   }
diff --git a/crates/api/src/local_user/ban_person.rs b/crates/api/src/local_user/ban_person.rs
index 2c2d363e3..30f8181e6 100644
--- a/crates/api/src/local_user/ban_person.rs
+++ b/crates/api/src/local_user/ban_person.rs
@@ -37,7 +37,7 @@ impl Perform for BanPerson {
     let expires = data.expires.map(naive_from_unix);
 
     let person = Person::update(
-      context.pool(),
+      &mut context.pool(),
       banned_person_id,
       &PersonUpdateForm::builder()
         .banned(Some(ban))
@@ -52,7 +52,7 @@ impl Perform for BanPerson {
     if remove_data {
       remove_user_data(
         person.id,
-        context.pool(),
+        &mut context.pool(),
         context.settings(),
         context.client(),
       )
@@ -68,10 +68,10 @@ impl Perform for BanPerson {
       expires,
     };
 
-    ModBan::create(context.pool(), &form).await?;
+    ModBan::create(&mut context.pool(), &form).await?;
 
     let person_id = data.person_id;
-    let person_view = PersonView::read(context.pool(), person_id).await?;
+    let person_view = PersonView::read(&mut context.pool(), person_id).await?;
 
     Ok(BanPersonResponse {
       person_view,
diff --git a/crates/api/src/local_user/block.rs b/crates/api/src/local_user/block.rs
index c9eaa2725..ef0d789ca 100644
--- a/crates/api/src/local_user/block.rs
+++ b/crates/api/src/local_user/block.rs
@@ -34,18 +34,18 @@ impl Perform for BlockPerson {
       target_id,
     };
 
-    let target_person_view = PersonView::read(context.pool(), target_id).await?;
+    let target_person_view = PersonView::read(&mut context.pool(), target_id).await?;
 
     if target_person_view.person.admin {
       return Err(LemmyError::from_message("cant_block_admin"));
     }
 
     if data.block {
-      PersonBlock::block(context.pool(), &person_block_form)
+      PersonBlock::block(&mut context.pool(), &person_block_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
     } else {
-      PersonBlock::unblock(context.pool(), &person_block_form)
+      PersonBlock::unblock(&mut context.pool(), &person_block_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
     }
diff --git a/crates/api/src/local_user/change_password.rs b/crates/api/src/local_user/change_password.rs
index 60e0b960d..e2e93da57 100644
--- a/crates/api/src/local_user/change_password.rs
+++ b/crates/api/src/local_user/change_password.rs
@@ -38,7 +38,7 @@ impl Perform for ChangePassword {
     let local_user_id = local_user_view.local_user.id;
     let new_password = data.new_password.clone();
     let updated_local_user =
-      LocalUser::update_password(context.pool(), local_user_id, &new_password).await?;
+      LocalUser::update_password(&mut context.pool(), local_user_id, &new_password).await?;
 
     // Return the jwt
     Ok(LoginResponse {
diff --git a/crates/api/src/local_user/change_password_after_reset.rs b/crates/api/src/local_user/change_password_after_reset.rs
index de05f8e59..9a78b24b6 100644
--- a/crates/api/src/local_user/change_password_after_reset.rs
+++ b/crates/api/src/local_user/change_password_after_reset.rs
@@ -22,7 +22,7 @@ impl Perform for PasswordChangeAfterReset {
 
     // Fetch the user_id from the token
     let token = data.token.clone();
-    let local_user_id = PasswordResetRequest::read_from_token(context.pool(), &token)
+    let local_user_id = PasswordResetRequest::read_from_token(&mut context.pool(), &token)
       .await
       .map(|p| p.local_user_id)?;
 
@@ -35,12 +35,13 @@ impl Perform for PasswordChangeAfterReset {
 
     // Update the user with the new password
     let password = data.password.clone();
-    let updated_local_user = LocalUser::update_password(context.pool(), local_user_id, &password)
-      .await
-      .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_user"))?;
+    let updated_local_user =
+      LocalUser::update_password(&mut context.pool(), local_user_id, &password)
+        .await
+        .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_user"))?;
 
     // Return the jwt if login is allowed
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
     let jwt = if site_view.local_site.registration_mode == RegistrationMode::RequireApplication
       && !updated_local_user.accepted_application
     {
diff --git a/crates/api/src/local_user/get_captcha.rs b/crates/api/src/local_user/get_captcha.rs
index 92653cfc6..5f1079ef2 100644
--- a/crates/api/src/local_user/get_captcha.rs
+++ b/crates/api/src/local_user/get_captcha.rs
@@ -17,7 +17,7 @@ impl Perform for GetCaptcha {
 
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     if !local_site.captcha_enabled {
       return Ok(GetCaptchaResponse { ok: None });
@@ -37,7 +37,7 @@ impl Perform for GetCaptcha {
 
     let captcha_form: CaptchaAnswerForm = CaptchaAnswerForm { answer };
     // Stores the captcha item in the db
-    let captcha = CaptchaAnswer::insert(context.pool(), &captcha_form).await?;
+    let captcha = CaptchaAnswer::insert(&mut context.pool(), &captcha_form).await?;
 
     Ok(GetCaptchaResponse {
       ok: Some(CaptchaResponse {
diff --git a/crates/api/src/local_user/list_banned.rs b/crates/api/src/local_user/list_banned.rs
index 5e2c027ba..9391a4bbf 100644
--- a/crates/api/src/local_user/list_banned.rs
+++ b/crates/api/src/local_user/list_banned.rs
@@ -19,7 +19,7 @@ impl Perform for GetBannedPersons {
     // Make sure user is an admin
     is_admin(&local_user_view)?;
 
-    let banned = PersonView::banned(context.pool()).await?;
+    let banned = PersonView::banned(&mut context.pool()).await?;
 
     Ok(Self::Response { banned })
   }
diff --git a/crates/api/src/local_user/login.rs b/crates/api/src/local_user/login.rs
index 9e211c9c4..dd2daf99c 100644
--- a/crates/api/src/local_user/login.rs
+++ b/crates/api/src/local_user/login.rs
@@ -17,13 +17,14 @@ impl Perform for Login {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
     let data: &Login = self;
 
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
 
     // Fetch that username / email
     let username_or_email = data.username_or_email.clone();
-    let local_user_view = LocalUserView::find_by_email_or_name(context.pool(), &username_or_email)
-      .await
-      .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;
+    let local_user_view =
+      LocalUserView::find_by_email_or_name(&mut context.pool(), &username_or_email)
+        .await
+        .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;
 
     // Verify the password
     let valid: bool = verify(
@@ -49,7 +50,8 @@ impl Perform for Login {
       return Err(LemmyError::from_message("email_not_verified"));
     }
 
-    check_registration_application(&local_user_view, &site_view.local_site, context.pool()).await?;
+    check_registration_application(&local_user_view, &site_view.local_site, &mut context.pool())
+      .await?;
 
     // Check the totp
     check_totp_2fa_valid(
diff --git a/crates/api/src/local_user/notifications/list_mentions.rs b/crates/api/src/local_user/notifications/list_mentions.rs
index 4c8d2cf55..1b2d3c7b6 100644
--- a/crates/api/src/local_user/notifications/list_mentions.rs
+++ b/crates/api/src/local_user/notifications/list_mentions.rs
@@ -28,7 +28,7 @@ impl Perform for GetPersonMentions {
     let show_bot_accounts = Some(local_user_view.local_user.show_bot_accounts);
 
     let mentions = PersonMentionQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .recipient_id(person_id)
       .my_person_id(person_id)
       .sort(sort)
diff --git a/crates/api/src/local_user/notifications/list_replies.rs b/crates/api/src/local_user/notifications/list_replies.rs
index 6d1d8f0bd..79b0fe223 100644
--- a/crates/api/src/local_user/notifications/list_replies.rs
+++ b/crates/api/src/local_user/notifications/list_replies.rs
@@ -25,7 +25,7 @@ impl Perform for GetReplies {
     let show_bot_accounts = Some(local_user_view.local_user.show_bot_accounts);
 
     let replies = CommentReplyQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .recipient_id(person_id)
       .my_person_id(person_id)
       .sort(sort)
diff --git a/crates/api/src/local_user/notifications/mark_all_read.rs b/crates/api/src/local_user/notifications/mark_all_read.rs
index cc2999698..564645596 100644
--- a/crates/api/src/local_user/notifications/mark_all_read.rs
+++ b/crates/api/src/local_user/notifications/mark_all_read.rs
@@ -23,17 +23,17 @@ impl Perform for MarkAllAsRead {
     let person_id = local_user_view.person.id;
 
     // Mark all comment_replies as read
-    CommentReply::mark_all_as_read(context.pool(), person_id)
+    CommentReply::mark_all_as_read(&mut context.pool(), person_id)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 
     // Mark all user mentions as read
-    PersonMention::mark_all_as_read(context.pool(), person_id)
+    PersonMention::mark_all_as_read(&mut context.pool(), person_id)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 
     // Mark all private_messages as read
-    PrivateMessage::mark_all_as_read(context.pool(), person_id)
+    PrivateMessage::mark_all_as_read(&mut context.pool(), person_id)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
 
diff --git a/crates/api/src/local_user/notifications/mark_mention_read.rs b/crates/api/src/local_user/notifications/mark_mention_read.rs
index dd3c413f2..661af40ab 100644
--- a/crates/api/src/local_user/notifications/mark_mention_read.rs
+++ b/crates/api/src/local_user/notifications/mark_mention_read.rs
@@ -25,7 +25,7 @@ impl Perform for MarkPersonMentionAsRead {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let person_mention_id = data.person_mention_id;
-    let read_person_mention = PersonMention::read(context.pool(), person_mention_id).await?;
+    let read_person_mention = PersonMention::read(&mut context.pool(), person_mention_id).await?;
 
     if local_user_view.person.id != read_person_mention.recipient_id {
       return Err(LemmyError::from_message("couldnt_update_comment"));
@@ -34,7 +34,7 @@ impl Perform for MarkPersonMentionAsRead {
     let person_mention_id = read_person_mention.id;
     let read = Some(data.read);
     PersonMention::update(
-      context.pool(),
+      &mut context.pool(),
       person_mention_id,
       &PersonMentionUpdateForm { read },
     )
@@ -44,7 +44,7 @@ impl Perform for MarkPersonMentionAsRead {
     let person_mention_id = read_person_mention.id;
     let person_id = local_user_view.person.id;
     let person_mention_view =
-      PersonMentionView::read(context.pool(), person_mention_id, Some(person_id)).await?;
+      PersonMentionView::read(&mut context.pool(), person_mention_id, Some(person_id)).await?;
 
     Ok(PersonMentionResponse {
       person_mention_view,
diff --git a/crates/api/src/local_user/notifications/mark_reply_read.rs b/crates/api/src/local_user/notifications/mark_reply_read.rs
index a8291cd50..07e368f4b 100644
--- a/crates/api/src/local_user/notifications/mark_reply_read.rs
+++ b/crates/api/src/local_user/notifications/mark_reply_read.rs
@@ -25,7 +25,7 @@ impl Perform for MarkCommentReplyAsRead {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let comment_reply_id = data.comment_reply_id;
-    let read_comment_reply = CommentReply::read(context.pool(), comment_reply_id).await?;
+    let read_comment_reply = CommentReply::read(&mut context.pool(), comment_reply_id).await?;
 
     if local_user_view.person.id != read_comment_reply.recipient_id {
       return Err(LemmyError::from_message("couldnt_update_comment"));
@@ -35,7 +35,7 @@ impl Perform for MarkCommentReplyAsRead {
     let read = Some(data.read);
 
     CommentReply::update(
-      context.pool(),
+      &mut context.pool(),
       comment_reply_id,
       &CommentReplyUpdateForm { read },
     )
@@ -45,7 +45,7 @@ impl Perform for MarkCommentReplyAsRead {
     let comment_reply_id = read_comment_reply.id;
     let person_id = local_user_view.person.id;
     let comment_reply_view =
-      CommentReplyView::read(context.pool(), comment_reply_id, Some(person_id)).await?;
+      CommentReplyView::read(&mut context.pool(), comment_reply_id, Some(person_id)).await?;
 
     Ok(CommentReplyResponse { comment_reply_view })
   }
diff --git a/crates/api/src/local_user/notifications/unread_count.rs b/crates/api/src/local_user/notifications/unread_count.rs
index 21e584d51..21622ddbf 100644
--- a/crates/api/src/local_user/notifications/unread_count.rs
+++ b/crates/api/src/local_user/notifications/unread_count.rs
@@ -20,12 +20,12 @@ impl Perform for GetUnreadCount {
 
     let person_id = local_user_view.person.id;
 
-    let replies = CommentReplyView::get_unread_replies(context.pool(), person_id).await?;
+    let replies = CommentReplyView::get_unread_replies(&mut context.pool(), person_id).await?;
 
-    let mentions = PersonMentionView::get_unread_mentions(context.pool(), person_id).await?;
+    let mentions = PersonMentionView::get_unread_mentions(&mut context.pool(), person_id).await?;
 
     let private_messages =
-      PrivateMessageView::get_unread_messages(context.pool(), person_id).await?;
+      PrivateMessageView::get_unread_messages(&mut context.pool(), person_id).await?;
 
     Ok(Self::Response {
       replies,
diff --git a/crates/api/src/local_user/report_count.rs b/crates/api/src/local_user/report_count.rs
index c09280d80..89bedc262 100644
--- a/crates/api/src/local_user/report_count.rs
+++ b/crates/api/src/local_user/report_count.rs
@@ -25,13 +25,14 @@ impl Perform for GetReportCount {
     let community_id = data.community_id;
 
     let comment_reports =
-      CommentReportView::get_report_count(context.pool(), person_id, admin, community_id).await?;
+      CommentReportView::get_report_count(&mut context.pool(), person_id, admin, community_id)
+        .await?;
 
     let post_reports =
-      PostReportView::get_report_count(context.pool(), person_id, admin, community_id).await?;
+      PostReportView::get_report_count(&mut context.pool(), person_id, admin, community_id).await?;
 
     let private_message_reports = if admin && community_id.is_none() {
-      Some(PrivateMessageReportView::get_report_count(context.pool()).await?)
+      Some(PrivateMessageReportView::get_report_count(&mut context.pool()).await?)
     } else {
       None
     };
diff --git a/crates/api/src/local_user/reset_password.rs b/crates/api/src/local_user/reset_password.rs
index b5325608d..818a918b4 100644
--- a/crates/api/src/local_user/reset_password.rs
+++ b/crates/api/src/local_user/reset_password.rs
@@ -22,13 +22,13 @@ impl Perform for PasswordReset {
 
     // Fetch that email
     let email = data.email.to_lowercase();
-    let local_user_view = LocalUserView::find_by_email(context.pool(), &email)
+    let local_user_view = LocalUserView::find_by_email(&mut context.pool(), &email)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;
 
     // Check for too many attempts (to limit potential abuse)
     let recent_resets_count = PasswordResetRequest::get_recent_password_resets_count(
-      context.pool(),
+      &mut context.pool(),
       local_user_view.local_user.id,
     )
     .await?;
@@ -37,7 +37,7 @@ impl Perform for PasswordReset {
     }
 
     // Email the pure token to the user.
-    send_password_reset_email(&local_user_view, context.pool(), context.settings()).await?;
+    send_password_reset_email(&local_user_view, &mut context.pool(), context.settings()).await?;
     Ok(PasswordResetResponse {})
   }
 }
diff --git a/crates/api/src/local_user/save_settings.rs b/crates/api/src/local_user/save_settings.rs
index 8f8d3194e..1c837c2b5 100644
--- a/crates/api/src/local_user/save_settings.rs
+++ b/crates/api/src/local_user/save_settings.rs
@@ -35,7 +35,7 @@ impl Perform for SaveUserSettings {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
     let data: &SaveUserSettings = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
 
     let avatar = diesel_option_overwrite_to_url(&data.avatar)?;
     let banner = diesel_option_overwrite_to_url(&data.banner)?;
@@ -49,8 +49,13 @@ impl Perform for SaveUserSettings {
       let previous_email = local_user_view.local_user.email.clone().unwrap_or_default();
       // Only send the verification email if there was an email change
       if previous_email.ne(email) {
-        send_verification_email(&local_user_view, email, context.pool(), context.settings())
-          .await?;
+        send_verification_email(
+          &local_user_view,
+          email,
+          &mut context.pool(),
+          context.settings(),
+        )
+        .await?;
       }
     }
 
@@ -90,12 +95,12 @@ impl Perform for SaveUserSettings {
       .banner(banner)
       .build();
 
-    Person::update(context.pool(), person_id, &person_form)
+    Person::update(&mut context.pool(), person_id, &person_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
 
     if let Some(discussion_languages) = data.discussion_languages.clone() {
-      LocalUserLanguage::update(context.pool(), discussion_languages, local_user_id).await?;
+      LocalUserLanguage::update(&mut context.pool(), discussion_languages, local_user_id).await?;
     }
 
     // If generate_totp is Some(false), this will clear it out from the database.
@@ -130,7 +135,8 @@ impl Perform for SaveUserSettings {
       .open_links_in_new_tab(data.open_links_in_new_tab)
       .build();
 
-    let local_user_res = LocalUser::update(context.pool(), local_user_id, &local_user_form).await;
+    let local_user_res =
+      LocalUser::update(&mut context.pool(), local_user_id, &local_user_form).await;
     let updated_local_user = match local_user_res {
       Ok(u) => u,
       Err(e) => {
diff --git a/crates/api/src/local_user/verify_email.rs b/crates/api/src/local_user/verify_email.rs
index 0807eebe0..bf7e9db5a 100644
--- a/crates/api/src/local_user/verify_email.rs
+++ b/crates/api/src/local_user/verify_email.rs
@@ -19,7 +19,7 @@ impl Perform for VerifyEmail {
 
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
     let token = self.token.clone();
-    let verification = EmailVerification::read_for_token(context.pool(), &token)
+    let verification = EmailVerification::read_for_token(&mut context.pool(), &token)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "token_not_found"))?;
 
@@ -31,9 +31,9 @@ impl Perform for VerifyEmail {
       .build();
     let local_user_id = verification.local_user_id;
 
-    LocalUser::update(context.pool(), local_user_id, &form).await?;
+    LocalUser::update(&mut context.pool(), local_user_id, &form).await?;
 
-    EmailVerification::delete_old_tokens_for_local_user(context.pool(), local_user_id).await?;
+    EmailVerification::delete_old_tokens_for_local_user(&mut context.pool(), local_user_id).await?;
 
     Ok(VerifyEmailResponse {})
   }
diff --git a/crates/api/src/post/feature.rs b/crates/api/src/post/feature.rs
index 3c9e1a1c0..c59eba313 100644
--- a/crates/api/src/post/feature.rs
+++ b/crates/api/src/post/feature.rs
@@ -32,20 +32,20 @@ impl Perform for FeaturePost {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
-    let orig_post = Post::read(context.pool(), post_id).await?;
+    let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
-    check_community_deleted_or_removed(orig_post.community_id, context.pool()).await?;
+    check_community_deleted_or_removed(orig_post.community_id, &mut context.pool()).await?;
 
     if data.feature_type == PostFeatureType::Community {
       // Verify that only the mods can feature in community
       is_mod_or_admin(
-        context.pool(),
+        &mut context.pool(),
         local_user_view.person.id,
         orig_post.community_id,
       )
@@ -65,7 +65,7 @@ impl Perform for FeaturePost {
         .featured_local(Some(data.featured))
         .build()
     };
-    Post::update(context.pool(), post_id, &new_post).await?;
+    Post::update(&mut context.pool(), post_id, &new_post).await?;
 
     // Mod tables
     let form = ModFeaturePostForm {
@@ -75,7 +75,7 @@ impl Perform for FeaturePost {
       is_featured_community: data.feature_type == PostFeatureType::Community,
     };
 
-    ModFeaturePost::create(context.pool(), &form).await?;
+    ModFeaturePost::create(&mut context.pool(), &form).await?;
 
     build_post_response(
       context,
diff --git a/crates/api/src/post/like.rs b/crates/api/src/post/like.rs
index 5811107c2..f275bbc40 100644
--- a/crates/api/src/post/like.rs
+++ b/crates/api/src/post/like.rs
@@ -29,17 +29,22 @@ impl Perform for CreatePostLike {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &CreatePostLike = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     // Don't do a downvote if site has downvotes disabled
     check_downvotes_enabled(data.score, &local_site)?;
 
     // Check for a community ban
     let post_id = data.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
 
-    check_community_ban(local_user_view.person.id, post.community_id, context.pool()).await?;
-    check_community_deleted_or_removed(post.community_id, context.pool()).await?;
+    check_community_ban(
+      local_user_view.person.id,
+      post.community_id,
+      &mut context.pool(),
+    )
+    .await?;
+    check_community_deleted_or_removed(post.community_id, &mut context.pool()).await?;
 
     let like_form = PostLikeForm {
       post_id: data.post_id,
@@ -50,18 +55,18 @@ impl Perform for CreatePostLike {
     // Remove any likes first
     let person_id = local_user_view.person.id;
 
-    PostLike::remove(context.pool(), person_id, post_id).await?;
+    PostLike::remove(&mut context.pool(), person_id, post_id).await?;
 
     // Only add the like if the score isnt 0
     let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
     if do_add {
-      PostLike::like(context.pool(), &like_form)
+      PostLike::like(&mut context.pool(), &like_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?;
     }
 
     // Mark the post as read
-    mark_post_as_read(person_id, post_id, context.pool()).await?;
+    mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
 
     build_post_response(
       context,
diff --git a/crates/api/src/post/lock.rs b/crates/api/src/post/lock.rs
index 5266d5441..627e9d8eb 100644
--- a/crates/api/src/post/lock.rs
+++ b/crates/api/src/post/lock.rs
@@ -30,19 +30,19 @@ impl Perform for LockPost {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
-    let orig_post = Post::read(context.pool(), post_id).await?;
+    let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
-    check_community_deleted_or_removed(orig_post.community_id, context.pool()).await?;
+    check_community_deleted_or_removed(orig_post.community_id, &mut context.pool()).await?;
 
     // Verify that only the mods can lock
     is_mod_or_admin(
-      context.pool(),
+      &mut context.pool(),
       local_user_view.person.id,
       orig_post.community_id,
     )
@@ -52,7 +52,7 @@ impl Perform for LockPost {
     let post_id = data.post_id;
     let locked = data.locked;
     Post::update(
-      context.pool(),
+      &mut context.pool(),
       post_id,
       &PostUpdateForm::builder().locked(Some(locked)).build(),
     )
@@ -64,7 +64,7 @@ impl Perform for LockPost {
       post_id: data.post_id,
       locked: Some(locked),
     };
-    ModLockPost::create(context.pool(), &form).await?;
+    ModLockPost::create(&mut context.pool(), &form).await?;
 
     build_post_response(
       context,
diff --git a/crates/api/src/post/mark_read.rs b/crates/api/src/post/mark_read.rs
index 0e013a883..0b777a7e1 100644
--- a/crates/api/src/post/mark_read.rs
+++ b/crates/api/src/post/mark_read.rs
@@ -22,13 +22,13 @@ impl Perform for MarkPostAsRead {
 
     // Mark the post as read / unread
     if data.read {
-      mark_post_as_read(person_id, post_id, context.pool()).await?;
+      mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
     } else {
-      mark_post_as_unread(person_id, post_id, context.pool()).await?;
+      mark_post_as_unread(person_id, post_id, &mut context.pool()).await?;
     }
 
     // Fetch it
-    let post_view = PostView::read(context.pool(), post_id, Some(person_id), None).await?;
+    let post_view = PostView::read(&mut context.pool(), post_id, Some(person_id), None).await?;
 
     Ok(Self::Response { post_view })
   }
diff --git a/crates/api/src/post/save.rs b/crates/api/src/post/save.rs
index 3213d2be6..fea6f43ad 100644
--- a/crates/api/src/post/save.rs
+++ b/crates/api/src/post/save.rs
@@ -27,21 +27,21 @@ impl Perform for SavePost {
     };
 
     if data.save {
-      PostSaved::save(context.pool(), &post_saved_form)
+      PostSaved::save(&mut context.pool(), &post_saved_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
     } else {
-      PostSaved::unsave(context.pool(), &post_saved_form)
+      PostSaved::unsave(&mut context.pool(), &post_saved_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
     }
 
     let post_id = data.post_id;
     let person_id = local_user_view.person.id;
-    let post_view = PostView::read(context.pool(), post_id, Some(person_id), None).await?;
+    let post_view = PostView::read(&mut context.pool(), post_id, Some(person_id), None).await?;
 
     // Mark the post as read
-    mark_post_as_read(person_id, post_id, context.pool()).await?;
+    mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
 
     Ok(PostResponse { post_view })
   }
diff --git a/crates/api/src/post_report/create.rs b/crates/api/src/post_report/create.rs
index 52bc3ce75..294506dd3 100644
--- a/crates/api/src/post_report/create.rs
+++ b/crates/api/src/post_report/create.rs
@@ -24,16 +24,16 @@ impl Perform for CreatePostReport {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> {
     let data: &CreatePostReport = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let reason = self.reason.trim();
     check_report_reason(reason, &local_site)?;
 
     let person_id = local_user_view.person.id;
     let post_id = data.post_id;
-    let post_view = PostView::read(context.pool(), post_id, None, None).await?;
+    let post_view = PostView::read(&mut context.pool(), post_id, None, None).await?;
 
-    check_community_ban(person_id, post_view.community.id, context.pool()).await?;
+    check_community_ban(person_id, post_view.community.id, &mut context.pool()).await?;
 
     let report_form = PostReportForm {
       creator_id: person_id,
@@ -44,18 +44,18 @@ impl Perform for CreatePostReport {
       reason: reason.to_owned(),
     };
 
-    let report = PostReport::report(context.pool(), &report_form)
+    let report = PostReport::report(&mut context.pool(), &report_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
 
-    let post_report_view = PostReportView::read(context.pool(), report.id, person_id).await?;
+    let post_report_view = PostReportView::read(&mut context.pool(), report.id, person_id).await?;
 
     // Email the admins
     if local_site.reports_email_admins {
       send_new_report_email_to_admins(
         &post_report_view.creator.name,
         &post_report_view.post_creator.name,
-        context.pool(),
+        &mut context.pool(),
         context.settings(),
       )
       .await?;
diff --git a/crates/api/src/post_report/list.rs b/crates/api/src/post_report/list.rs
index d8473f736..f7496e1a3 100644
--- a/crates/api/src/post_report/list.rs
+++ b/crates/api/src/post_report/list.rs
@@ -30,7 +30,7 @@ impl Perform for ListPostReports {
     let page = data.page;
     let limit = data.limit;
     let post_reports = PostReportQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .my_person_id(person_id)
       .admin(admin)
       .community_id(community_id)
diff --git a/crates/api/src/post_report/resolve.rs b/crates/api/src/post_report/resolve.rs
index cc6d0510f..89a65d02c 100644
--- a/crates/api/src/post_report/resolve.rs
+++ b/crates/api/src/post_report/resolve.rs
@@ -21,22 +21,22 @@ impl Perform for ResolvePostReport {
 
     let report_id = data.report_id;
     let person_id = local_user_view.person.id;
-    let report = PostReportView::read(context.pool(), report_id, person_id).await?;
+    let report = PostReportView::read(&mut context.pool(), report_id, person_id).await?;
 
     let person_id = local_user_view.person.id;
-    is_mod_or_admin(context.pool(), person_id, report.community.id).await?;
+    is_mod_or_admin(&mut context.pool(), person_id, report.community.id).await?;
 
     if data.resolved {
-      PostReport::resolve(context.pool(), report_id, person_id)
+      PostReport::resolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     } else {
-      PostReport::unresolve(context.pool(), report_id, person_id)
+      PostReport::unresolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     }
 
-    let post_report_view = PostReportView::read(context.pool(), report_id, person_id).await?;
+    let post_report_view = PostReportView::read(&mut context.pool(), report_id, person_id).await?;
 
     Ok(PostReportResponse { post_report_view })
   }
diff --git a/crates/api/src/private_message/mark_read.rs b/crates/api/src/private_message/mark_read.rs
index ca3431742..16a784c6f 100644
--- a/crates/api/src/private_message/mark_read.rs
+++ b/crates/api/src/private_message/mark_read.rs
@@ -26,7 +26,8 @@ impl Perform for MarkPrivateMessageAsRead {
 
     // Checking permissions
     let private_message_id = data.private_message_id;
-    let orig_private_message = PrivateMessage::read(context.pool(), private_message_id).await?;
+    let orig_private_message =
+      PrivateMessage::read(&mut context.pool(), private_message_id).await?;
     if local_user_view.person.id != orig_private_message.recipient_id {
       return Err(LemmyError::from_message("couldnt_update_private_message"));
     }
@@ -35,14 +36,14 @@ impl Perform for MarkPrivateMessageAsRead {
     let private_message_id = data.private_message_id;
     let read = data.read;
     PrivateMessage::update(
-      context.pool(),
+      &mut context.pool(),
       private_message_id,
       &PrivateMessageUpdateForm::builder().read(Some(read)).build(),
     )
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
 
-    let view = PrivateMessageView::read(context.pool(), private_message_id).await?;
+    let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
     Ok(PrivateMessageResponse {
       private_message_view: view,
     })
diff --git a/crates/api/src/private_message_report/create.rs b/crates/api/src/private_message_report/create.rs
index 2a2feef34..04e95e398 100644
--- a/crates/api/src/private_message_report/create.rs
+++ b/crates/api/src/private_message_report/create.rs
@@ -23,14 +23,14 @@ impl Perform for CreatePrivateMessageReport {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
     let local_user_view = local_user_view_from_jwt(&self.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let reason = self.reason.trim();
     check_report_reason(reason, &local_site)?;
 
     let person_id = local_user_view.person.id;
     let private_message_id = self.private_message_id;
-    let private_message = PrivateMessage::read(context.pool(), private_message_id).await?;
+    let private_message = PrivateMessage::read(&mut context.pool(), private_message_id).await?;
 
     let report_form = PrivateMessageReportForm {
       creator_id: person_id,
@@ -39,19 +39,19 @@ impl Perform for CreatePrivateMessageReport {
       reason: reason.to_owned(),
     };
 
-    let report = PrivateMessageReport::report(context.pool(), &report_form)
+    let report = PrivateMessageReport::report(&mut context.pool(), &report_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
 
     let private_message_report_view =
-      PrivateMessageReportView::read(context.pool(), report.id).await?;
+      PrivateMessageReportView::read(&mut context.pool(), report.id).await?;
 
     // Email the admins
     if local_site.reports_email_admins {
       send_new_report_email_to_admins(
         &private_message_report_view.creator.name,
         &private_message_report_view.private_message_creator.name,
-        context.pool(),
+        &mut context.pool(),
         context.settings(),
       )
       .await?;
diff --git a/crates/api/src/private_message_report/list.rs b/crates/api/src/private_message_report/list.rs
index 62c07325c..72d182d45 100644
--- a/crates/api/src/private_message_report/list.rs
+++ b/crates/api/src/private_message_report/list.rs
@@ -22,7 +22,7 @@ impl Perform for ListPrivateMessageReports {
     let page = self.page;
     let limit = self.limit;
     let private_message_reports = PrivateMessageReportQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .unresolved_only(unresolved_only)
       .page(page)
       .limit(limit)
diff --git a/crates/api/src/private_message_report/resolve.rs b/crates/api/src/private_message_report/resolve.rs
index e4fcfc856..7c9e7a810 100644
--- a/crates/api/src/private_message_report/resolve.rs
+++ b/crates/api/src/private_message_report/resolve.rs
@@ -22,17 +22,17 @@ impl Perform for ResolvePrivateMessageReport {
     let report_id = self.report_id;
     let person_id = local_user_view.person.id;
     if self.resolved {
-      PrivateMessageReport::resolve(context.pool(), report_id, person_id)
+      PrivateMessageReport::resolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     } else {
-      PrivateMessageReport::unresolve(context.pool(), report_id, person_id)
+      PrivateMessageReport::unresolve(&mut context.pool(), report_id, person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
     }
 
     let private_message_report_view =
-      PrivateMessageReportView::read(context.pool(), report_id).await?;
+      PrivateMessageReportView::read(&mut context.pool(), report_id).await?;
 
     Ok(PrivateMessageReportResponse {
       private_message_report_view,
diff --git a/crates/api/src/site/federated_instances.rs b/crates/api/src/site/federated_instances.rs
index 0d2b83bc0..43383e067 100644
--- a/crates/api/src/site/federated_instances.rs
+++ b/crates/api/src/site/federated_instances.rs
@@ -14,9 +14,9 @@ impl Perform for GetFederatedInstances {
 
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
     let federated_instances =
-      build_federated_instances(&site_view.local_site, context.pool()).await?;
+      build_federated_instances(&site_view.local_site, &mut context.pool()).await?;
 
     Ok(Self::Response {
       federated_instances,
diff --git a/crates/api/src/site/leave_admin.rs b/crates/api/src/site/leave_admin.rs
index d7c0cf3aa..ab5991e1b 100644
--- a/crates/api/src/site/leave_admin.rs
+++ b/crates/api/src/site/leave_admin.rs
@@ -31,14 +31,14 @@ impl Perform for LeaveAdmin {
     is_admin(&local_user_view)?;
 
     // Make sure there isn't just one admin (so if one leaves, there will still be one left)
-    let admins = PersonView::admins(context.pool()).await?;
+    let admins = PersonView::admins(&mut context.pool()).await?;
     if admins.len() == 1 {
       return Err(LemmyError::from_message("cannot_leave_admin"));
     }
 
     let person_id = local_user_view.person.id;
     Person::update(
-      context.pool(),
+      &mut context.pool(),
       person_id,
       &PersonUpdateForm::builder().admin(Some(false)).build(),
     )
@@ -51,16 +51,17 @@ impl Perform for LeaveAdmin {
       removed: Some(true),
     };
 
-    ModAdd::create(context.pool(), &form).await?;
+    ModAdd::create(&mut context.pool(), &form).await?;
 
     // Reread site and admins
-    let site_view = SiteView::read_local(context.pool()).await?;
-    let admins = PersonView::admins(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
+    let admins = PersonView::admins(&mut context.pool()).await?;
 
-    let all_languages = Language::read_all(context.pool()).await?;
-    let discussion_languages = SiteLanguage::read_local_raw(context.pool()).await?;
-    let taglines = Tagline::get_all(context.pool(), site_view.local_site.id).await?;
-    let custom_emojis = CustomEmojiView::get_all(context.pool(), site_view.local_site.id).await?;
+    let all_languages = Language::read_all(&mut context.pool()).await?;
+    let discussion_languages = SiteLanguage::read_local_raw(&mut context.pool()).await?;
+    let taglines = Tagline::get_all(&mut context.pool(), site_view.local_site.id).await?;
+    let custom_emojis =
+      CustomEmojiView::get_all(&mut context.pool(), site_view.local_site.id).await?;
 
     Ok(GetSiteResponse {
       site_view,
diff --git a/crates/api/src/site/mod_log.rs b/crates/api/src/site/mod_log.rs
index 2ca725150..a06689804 100644
--- a/crates/api/src/site/mod_log.rs
+++ b/crates/api/src/site/mod_log.rs
@@ -40,7 +40,7 @@ impl Perform for GetModlog {
     let data: &GetModlog = self;
 
     let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     check_private_instance(&local_user_view, &local_site)?;
 
@@ -56,7 +56,7 @@ impl Perform for GetModlog {
       None => CommunityId(-1),
     };
     let is_mod_of_community = data.community_id.is_some()
-      && is_mod_or_admin(context.pool(), local_person_id, community_id_value)
+      && is_mod_or_admin(&mut context.pool(), local_person_id, community_id_value)
         .await
         .is_ok();
     let hide_modlog_names = local_site.hide_modlog_mod_names && !is_mod_of_community && !is_admin;
@@ -76,43 +76,47 @@ impl Perform for GetModlog {
       hide_modlog_names,
     };
     let removed_posts = match type_ {
-      All | ModRemovePost => ModRemovePostView::list(context.pool(), params).await?,
+      All | ModRemovePost => ModRemovePostView::list(&mut context.pool(), params).await?,
       _ => Default::default(),
     };
 
     let locked_posts = match type_ {
-      All | ModLockPost => ModLockPostView::list(context.pool(), params).await?,
+      All | ModLockPost => ModLockPostView::list(&mut context.pool(), params).await?,
       _ => Default::default(),
     };
 
     let featured_posts = match type_ {
-      All | ModFeaturePost => ModFeaturePostView::list(context.pool(), params).await?,
+      All | ModFeaturePost => ModFeaturePostView::list(&mut context.pool(), params).await?,
       _ => Default::default(),
     };
 
     let removed_comments = match type_ {
-      All | ModRemoveComment => ModRemoveCommentView::list(context.pool(), params).await?,
+      All | ModRemoveComment => ModRemoveCommentView::list(&mut context.pool(), params).await?,
       _ => Default::default(),
     };
 
     let banned_from_community = match type_ {
-      All | ModBanFromCommunity => ModBanFromCommunityView::list(context.pool(), params).await?,
+      All | ModBanFromCommunity => {
+        ModBanFromCommunityView::list(&mut context.pool(), params).await?
+      }
       _ => Default::default(),
     };
 
     let added_to_community = match type_ {
-      All | ModAddCommunity => ModAddCommunityView::list(context.pool(), params).await?,
+      All | ModAddCommunity => ModAddCommunityView::list(&mut context.pool(), params).await?,
       _ => Default::default(),
     };
 
     let transferred_to_community = match type_ {
-      All | ModTransferCommunity => ModTransferCommunityView::list(context.pool(), params).await?,
+      All | ModTransferCommunity => {
+        ModTransferCommunityView::list(&mut context.pool(), params).await?
+      }
       _ => Default::default(),
     };
 
     let hidden_communities = match type_ {
       All | ModHideCommunity if other_person_id.is_none() => {
-        ModHideCommunityView::list(context.pool(), params).await?
+        ModHideCommunityView::list(&mut context.pool(), params).await?
       }
       _ => Default::default(),
     };
@@ -129,40 +133,40 @@ impl Perform for GetModlog {
     ) = if data.community_id.is_none() {
       (
         match type_ {
-          All | ModBan => ModBanView::list(context.pool(), params).await?,
+          All | ModBan => ModBanView::list(&mut context.pool(), params).await?,
           _ => Default::default(),
         },
         match type_ {
-          All | ModAdd => ModAddView::list(context.pool(), params).await?,
+          All | ModAdd => ModAddView::list(&mut context.pool(), params).await?,
           _ => Default::default(),
         },
         match type_ {
           All | ModRemoveCommunity if other_person_id.is_none() => {
-            ModRemoveCommunityView::list(context.pool(), params).await?
+            ModRemoveCommunityView::list(&mut context.pool(), params).await?
           }
           _ => Default::default(),
         },
         match type_ {
           All | AdminPurgePerson if other_person_id.is_none() => {
-            AdminPurgePersonView::list(context.pool(), params).await?
+            AdminPurgePersonView::list(&mut context.pool(), params).await?
           }
           _ => Default::default(),
         },
         match type_ {
           All | AdminPurgeCommunity if other_person_id.is_none() => {
-            AdminPurgeCommunityView::list(context.pool(), params).await?
+            AdminPurgeCommunityView::list(&mut context.pool(), params).await?
           }
           _ => Default::default(),
         },
         match type_ {
           All | AdminPurgePost if other_person_id.is_none() => {
-            AdminPurgePostView::list(context.pool(), params).await?
+            AdminPurgePostView::list(&mut context.pool(), params).await?
           }
           _ => Default::default(),
         },
         match type_ {
           All | AdminPurgeComment if other_person_id.is_none() => {
-            AdminPurgeCommentView::list(context.pool(), params).await?
+            AdminPurgeCommentView::list(&mut context.pool(), params).await?
           }
           _ => Default::default(),
         },
diff --git a/crates/api/src/site/purge/comment.rs b/crates/api/src/site/purge/comment.rs
index 7beba9c0b..9334961e9 100644
--- a/crates/api/src/site/purge/comment.rs
+++ b/crates/api/src/site/purge/comment.rs
@@ -29,13 +29,13 @@ impl Perform for PurgeComment {
     let comment_id = data.comment_id;
 
     // Read the comment to get the post_id
-    let comment = Comment::read(context.pool(), comment_id).await?;
+    let comment = Comment::read(&mut context.pool(), comment_id).await?;
 
     let post_id = comment.post_id;
 
     // TODO read comments for pictrs images and purge them
 
-    Comment::delete(context.pool(), comment_id).await?;
+    Comment::delete(&mut context.pool(), comment_id).await?;
 
     // Mod tables
     let reason = data.reason.clone();
@@ -45,7 +45,7 @@ impl Perform for PurgeComment {
       post_id,
     };
 
-    AdminPurgeComment::create(context.pool(), &form).await?;
+    AdminPurgeComment::create(&mut context.pool(), &form).await?;
 
     Ok(PurgeItemResponse { success: true })
   }
diff --git a/crates/api/src/site/purge/community.rs b/crates/api/src/site/purge/community.rs
index 50482b73a..56e757176 100644
--- a/crates/api/src/site/purge/community.rs
+++ b/crates/api/src/site/purge/community.rs
@@ -30,7 +30,7 @@ impl Perform for PurgeCommunity {
     let community_id = data.community_id;
 
     // Read the community to get its images
-    let community = Community::read(context.pool(), community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
 
     if let Some(banner) = community.banner {
       purge_image_from_pictrs(context.client(), context.settings(), &banner)
@@ -46,13 +46,13 @@ impl Perform for PurgeCommunity {
 
     purge_image_posts_for_community(
       community_id,
-      context.pool(),
+      &mut context.pool(),
       context.settings(),
       context.client(),
     )
     .await?;
 
-    Community::delete(context.pool(), community_id).await?;
+    Community::delete(&mut context.pool(), community_id).await?;
 
     // Mod tables
     let reason = data.reason.clone();
@@ -61,7 +61,7 @@ impl Perform for PurgeCommunity {
       reason,
     };
 
-    AdminPurgeCommunity::create(context.pool(), &form).await?;
+    AdminPurgeCommunity::create(&mut context.pool(), &form).await?;
 
     Ok(PurgeItemResponse { success: true })
   }
diff --git a/crates/api/src/site/purge/person.rs b/crates/api/src/site/purge/person.rs
index f0cbc7e8d..fa884147f 100644
--- a/crates/api/src/site/purge/person.rs
+++ b/crates/api/src/site/purge/person.rs
@@ -29,7 +29,7 @@ impl Perform for PurgePerson {
 
     // Read the person to get their images
     let person_id = data.person_id;
-    let person = Person::read(context.pool(), person_id).await?;
+    let person = Person::read(&mut context.pool(), person_id).await?;
 
     if let Some(banner) = person.banner {
       purge_image_from_pictrs(context.client(), context.settings(), &banner)
@@ -45,13 +45,13 @@ impl Perform for PurgePerson {
 
     purge_image_posts_for_person(
       person_id,
-      context.pool(),
+      &mut context.pool(),
       context.settings(),
       context.client(),
     )
     .await?;
 
-    Person::delete(context.pool(), person_id).await?;
+    Person::delete(&mut context.pool(), person_id).await?;
 
     // Mod tables
     let reason = data.reason.clone();
@@ -60,7 +60,7 @@ impl Perform for PurgePerson {
       reason,
     };
 
-    AdminPurgePerson::create(context.pool(), &form).await?;
+    AdminPurgePerson::create(&mut context.pool(), &form).await?;
 
     Ok(PurgeItemResponse { success: true })
   }
diff --git a/crates/api/src/site/purge/post.rs b/crates/api/src/site/purge/post.rs
index 65d390f8e..6824e408b 100644
--- a/crates/api/src/site/purge/post.rs
+++ b/crates/api/src/site/purge/post.rs
@@ -30,7 +30,7 @@ impl Perform for PurgePost {
     let post_id = data.post_id;
 
     // Read the post to get the community_id
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
 
     // Purge image
     if let Some(url) = post.url {
@@ -47,7 +47,7 @@ impl Perform for PurgePost {
 
     let community_id = post.community_id;
 
-    Post::delete(context.pool(), post_id).await?;
+    Post::delete(&mut context.pool(), post_id).await?;
 
     // Mod tables
     let reason = data.reason.clone();
@@ -57,7 +57,7 @@ impl Perform for PurgePost {
       community_id,
     };
 
-    AdminPurgePost::create(context.pool(), &form).await?;
+    AdminPurgePost::create(&mut context.pool(), &form).await?;
 
     Ok(PurgeItemResponse { success: true })
   }
diff --git a/crates/api/src/site/registration_applications/approve.rs b/crates/api/src/site/registration_applications/approve.rs
index b7f672e61..253f3ffa1 100644
--- a/crates/api/src/site/registration_applications/approve.rs
+++ b/crates/api/src/site/registration_applications/approve.rs
@@ -37,7 +37,7 @@ impl Perform for ApproveRegistrationApplication {
     };
 
     let registration_application =
-      RegistrationApplication::update(context.pool(), app_id, &app_form).await?;
+      RegistrationApplication::update(&mut context.pool(), app_id, &app_form).await?;
 
     // Update the local_user row
     let local_user_form = LocalUserUpdateForm::builder()
@@ -45,10 +45,11 @@ impl Perform for ApproveRegistrationApplication {
       .build();
 
     let approved_user_id = registration_application.local_user_id;
-    LocalUser::update(context.pool(), approved_user_id, &local_user_form).await?;
+    LocalUser::update(&mut context.pool(), approved_user_id, &local_user_form).await?;
 
     if data.approve {
-      let approved_local_user_view = LocalUserView::read(context.pool(), approved_user_id).await?;
+      let approved_local_user_view =
+        LocalUserView::read(&mut context.pool(), approved_user_id).await?;
 
       if approved_local_user_view.local_user.email.is_some() {
         send_application_approved_email(&approved_local_user_view, context.settings())?;
@@ -57,7 +58,7 @@ impl Perform for ApproveRegistrationApplication {
 
     // Read the view
     let registration_application =
-      RegistrationApplicationView::read(context.pool(), app_id).await?;
+      RegistrationApplicationView::read(&mut context.pool(), app_id).await?;
 
     Ok(Self::Response {
       registration_application,
diff --git a/crates/api/src/site/registration_applications/list.rs b/crates/api/src/site/registration_applications/list.rs
index 6a3599577..2389ad403 100644
--- a/crates/api/src/site/registration_applications/list.rs
+++ b/crates/api/src/site/registration_applications/list.rs
@@ -17,7 +17,7 @@ impl Perform for ListRegistrationApplications {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
     let data = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     // Make sure user is an admin
     is_admin(&local_user_view)?;
@@ -28,7 +28,7 @@ impl Perform for ListRegistrationApplications {
     let page = data.page;
     let limit = data.limit;
     let registration_applications = RegistrationApplicationQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .unread_only(unread_only)
       .verified_email_only(Some(verified_email_only))
       .page(page)
diff --git a/crates/api/src/site/registration_applications/unread_count.rs b/crates/api/src/site/registration_applications/unread_count.rs
index aed07c708..593e93ffb 100644
--- a/crates/api/src/site/registration_applications/unread_count.rs
+++ b/crates/api/src/site/registration_applications/unread_count.rs
@@ -16,7 +16,7 @@ impl Perform for GetUnreadRegistrationApplicationCount {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
     let data = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     // Only let admins do this
     is_admin(&local_user_view)?;
@@ -24,7 +24,8 @@ impl Perform for GetUnreadRegistrationApplicationCount {
     let verified_email_only = local_site.require_email_verification;
 
     let registration_applications =
-      RegistrationApplicationView::get_unread_count(context.pool(), verified_email_only).await?;
+      RegistrationApplicationView::get_unread_count(&mut context.pool(), verified_email_only)
+        .await?;
 
     Ok(Self::Response {
       registration_applications,
diff --git a/crates/api_common/src/build_response.rs b/crates/api_common/src/build_response.rs
index 328827b2c..07e3b6e4f 100644
--- a/crates/api_common/src/build_response.rs
+++ b/crates/api_common/src/build_response.rs
@@ -30,7 +30,7 @@ pub async fn build_comment_response(
   recipient_ids: Vec<LocalUserId>,
 ) -> Result<CommentResponse, LemmyError> {
   let person_id = local_user_view.map(|l| l.person.id);
-  let comment_view = CommentView::read(context.pool(), comment_id, person_id).await?;
+  let comment_view = CommentView::read(&mut context.pool(), comment_id, person_id).await?;
   Ok(CommentResponse {
     comment_view,
     recipient_ids,
@@ -43,18 +43,19 @@ pub async fn build_community_response(
   local_user_view: LocalUserView,
   community_id: CommunityId,
 ) -> Result<CommunityResponse, LemmyError> {
-  let is_mod_or_admin = is_mod_or_admin(context.pool(), local_user_view.person.id, community_id)
-    .await
-    .is_ok();
+  let is_mod_or_admin =
+    is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id)
+      .await
+      .is_ok();
   let person_id = local_user_view.person.id;
   let community_view = CommunityView::read(
-    context.pool(),
+    &mut context.pool(),
     community_id,
     Some(person_id),
     Some(is_mod_or_admin),
   )
   .await?;
-  let discussion_languages = CommunityLanguage::read(context.pool(), community_id).await?;
+  let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
 
   Ok(CommunityResponse {
     community_view,
@@ -68,11 +69,11 @@ pub async fn build_post_response(
   person_id: PersonId,
   post_id: PostId,
 ) -> Result<PostResponse, LemmyError> {
-  let is_mod_or_admin = is_mod_or_admin(context.pool(), person_id, community_id)
+  let is_mod_or_admin = is_mod_or_admin(&mut context.pool(), person_id, community_id)
     .await
     .is_ok();
   let post_view = PostView::read(
-    context.pool(),
+    &mut context.pool(),
     post_id,
     Some(person_id),
     Some(is_mod_or_admin),
@@ -100,7 +101,7 @@ pub async fn send_local_notifs(
     .filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name))
   {
     let mention_name = mention.name.clone();
-    let user_view = LocalUserView::read_from_name(context.pool(), &mention_name).await;
+    let user_view = LocalUserView::read_from_name(&mut context.pool(), &mention_name).await;
     if let Ok(mention_user_view) = user_view {
       // TODO
       // At some point, make it so you can't tag the parent creator either
@@ -115,7 +116,7 @@ pub async fn send_local_notifs(
 
       // Allow this to fail softly, since comment edits might re-update or replace it
       // Let the uniqueness handle this fail
-      PersonMention::create(context.pool(), &user_mention_form)
+      PersonMention::create(&mut context.pool(), &user_mention_form)
         .await
         .ok();
 
@@ -134,19 +135,19 @@ pub async fn send_local_notifs(
 
   // Send comment_reply to the parent commenter / poster
   if let Some(parent_comment_id) = comment.parent_comment_id() {
-    let parent_comment = Comment::read(context.pool(), parent_comment_id).await?;
+    let parent_comment = Comment::read(&mut context.pool(), parent_comment_id).await?;
 
     // Get the parent commenter local_user
     let parent_creator_id = parent_comment.creator_id;
 
     // Only add to recipients if that person isn't blocked
-    let creator_blocked = check_person_block(person.id, parent_creator_id, context.pool())
+    let creator_blocked = check_person_block(person.id, parent_creator_id, &mut context.pool())
       .await
       .is_err();
 
     // Don't send a notif to yourself
     if parent_comment.creator_id != person.id && !creator_blocked {
-      let user_view = LocalUserView::read_person(context.pool(), parent_creator_id).await;
+      let user_view = LocalUserView::read_person(&mut context.pool(), parent_creator_id).await;
       if let Ok(parent_user_view) = user_view {
         recipient_ids.push(parent_user_view.local_user.id);
 
@@ -158,7 +159,7 @@ pub async fn send_local_notifs(
 
         // Allow this to fail softly, since comment edits might re-update or replace it
         // Let the uniqueness handle this fail
-        CommentReply::create(context.pool(), &comment_reply_form)
+        CommentReply::create(&mut context.pool(), &comment_reply_form)
           .await
           .ok();
 
@@ -176,13 +177,13 @@ pub async fn send_local_notifs(
   } else {
     // If there's no parent, its the post creator
     // Only add to recipients if that person isn't blocked
-    let creator_blocked = check_person_block(person.id, post.creator_id, context.pool())
+    let creator_blocked = check_person_block(person.id, post.creator_id, &mut context.pool())
       .await
       .is_err();
 
     if post.creator_id != person.id && !creator_blocked {
       let creator_id = post.creator_id;
-      let parent_user = LocalUserView::read_person(context.pool(), creator_id).await;
+      let parent_user = LocalUserView::read_person(&mut context.pool(), creator_id).await;
       if let Ok(parent_user_view) = parent_user {
         recipient_ids.push(parent_user_view.local_user.id);
 
@@ -194,7 +195,7 @@ pub async fn send_local_notifs(
 
         // Allow this to fail softly, since comment edits might re-update or replace it
         // Let the uniqueness handle this fail
-        CommentReply::create(context.pool(), &comment_reply_form)
+        CommentReply::create(&mut context.pool(), &comment_reply_form)
           .await
           .ok();
 
diff --git a/crates/api_common/src/context.rs b/crates/api_common/src/context.rs
index 42fa74964..ef2a24a07 100644
--- a/crates/api_common/src/context.rs
+++ b/crates/api_common/src/context.rs
@@ -1,4 +1,7 @@
-use lemmy_db_schema::{source::secret::Secret, utils::DbPool};
+use lemmy_db_schema::{
+  source::secret::Secret,
+  utils::{DbPool, DbPoolRef, OwnedDbPool},
+};
 use lemmy_utils::{
   rate_limit::RateLimitCell,
   settings::{structs::Settings, SETTINGS},
@@ -8,7 +11,7 @@ use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct LemmyContext {
-  pool: DbPool,
+  pool: OwnedDbPool,
   client: Arc<ClientWithMiddleware>,
   secret: Arc<Secret>,
   rate_limit_cell: RateLimitCell,
@@ -16,7 +19,7 @@ pub struct LemmyContext {
 
 impl LemmyContext {
   pub fn create(
-    pool: DbPool,
+    pool: OwnedDbPool,
     client: ClientWithMiddleware,
     secret: Secret,
     rate_limit_cell: RateLimitCell,
@@ -28,8 +31,8 @@ impl LemmyContext {
       rate_limit_cell,
     }
   }
-  pub fn pool(&self) -> &DbPool {
-    &self.pool
+  pub fn pool(&self) -> DbPool<'_> {
+    DbPool::Pool(&self.pool)
   }
   pub fn client(&self) -> &ClientWithMiddleware {
     &self.client
diff --git a/crates/api_common/src/utils.rs b/crates/api_common/src/utils.rs
index fd143ed90..838a47073 100644
--- a/crates/api_common/src/utils.rs
+++ b/crates/api_common/src/utils.rs
@@ -25,6 +25,7 @@ use lemmy_db_schema::{
   },
   traits::{Crud, Readable},
   utils::DbPool,
+  DbPoolRef,
   RegistrationMode,
 };
 use lemmy_db_views::{comment_view::CommentQuery, structs::LocalUserView};
@@ -50,7 +51,7 @@ use url::{ParseError, Url};
 
 #[tracing::instrument(skip_all)]
 pub async fn is_mod_or_admin(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   person_id: PersonId,
   community_id: CommunityId,
 ) -> Result<(), LemmyError> {
@@ -63,7 +64,7 @@ pub async fn is_mod_or_admin(
 
 #[tracing::instrument(skip_all)]
 pub async fn is_mod_or_admin_opt(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   local_user_view: Option<&LocalUserView>,
   community_id: Option<CommunityId>,
 ) -> Result<(), LemmyError> {
@@ -101,7 +102,7 @@ pub fn is_top_mod(
 }
 
 #[tracing::instrument(skip_all)]
-pub async fn get_post(post_id: PostId, pool: &DbPool) -> Result<Post, LemmyError> {
+pub async fn get_post(post_id: PostId, pool: DbPoolRef<'_>) -> Result<Post, LemmyError> {
   Post::read(pool, post_id)
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))
@@ -111,7 +112,7 @@ pub async fn get_post(post_id: PostId, pool: &DbPool) -> Result<Post, LemmyError
 pub async fn mark_post_as_read(
   person_id: PersonId,
   post_id: PostId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<PostRead, LemmyError> {
   let post_read_form = PostReadForm { post_id, person_id };
 
@@ -124,7 +125,7 @@ pub async fn mark_post_as_read(
 pub async fn mark_post_as_unread(
   person_id: PersonId,
   post_id: PostId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<usize, LemmyError> {
   let post_read_form = PostReadForm { post_id, person_id };
 
@@ -142,7 +143,7 @@ pub async fn local_user_view_from_jwt(
     .map_err(|e| e.with_message("not_logged_in"))?
     .claims;
   let local_user_id = LocalUserId(claims.sub);
-  let local_user_view = LocalUserView::read(context.pool(), local_user_id).await?;
+  let local_user_view = LocalUserView::read(&mut context.pool(), local_user_id).await?;
   check_user_valid(
     local_user_view.person.banned,
     local_user_view.person.ban_expires,
@@ -197,7 +198,7 @@ pub fn check_user_valid(
 pub async fn check_community_ban(
   person_id: PersonId,
   community_id: CommunityId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<(), LemmyError> {
   let is_banned = CommunityPersonBanView::get(pool, person_id, community_id)
     .await
@@ -212,7 +213,7 @@ pub async fn check_community_ban(
 #[tracing::instrument(skip_all)]
 pub async fn check_community_deleted_or_removed(
   community_id: CommunityId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<(), LemmyError> {
   let community = Community::read(pool, community_id)
     .await
@@ -236,7 +237,7 @@ pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> {
 pub async fn check_person_block(
   my_id: PersonId,
   potential_blocker_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<(), LemmyError> {
   let is_blocked = PersonBlock::read(pool, potential_blocker_id, my_id)
     .await
@@ -270,7 +271,7 @@ pub fn check_private_instance(
 #[tracing::instrument(skip_all)]
 pub async fn build_federated_instances(
   local_site: &LocalSite,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<Option<FederatedInstances>, LemmyError> {
   if local_site.federation_enabled {
     // TODO I hate that this requires 3 queries
@@ -334,7 +335,7 @@ pub fn send_email_to_user(
 
 pub async fn send_password_reset_email(
   user: &LocalUserView,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
 ) -> Result<(), LemmyError> {
   // Generate a random token
@@ -358,7 +359,7 @@ pub async fn send_password_reset_email(
 pub async fn send_verification_email(
   user: &LocalUserView,
   new_email: &str,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
 ) -> Result<(), LemmyError> {
   let form = EmailVerificationForm {
@@ -449,7 +450,7 @@ pub fn send_application_approved_email(
 /// Send a new applicant email notification to all admins
 pub async fn send_new_applicant_email_to_admins(
   applicant_username: &str,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
 ) -> Result<(), LemmyError> {
   // Collect the admins with emails
@@ -474,7 +475,7 @@ pub async fn send_new_applicant_email_to_admins(
 pub async fn send_new_report_email_to_admins(
   reporter_username: &str,
   reported_username: &str,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
 ) -> Result<(), LemmyError> {
   // Collect the admins with emails
@@ -495,7 +496,7 @@ pub async fn send_new_report_email_to_admins(
 pub async fn check_registration_application(
   local_user_view: &LocalUserView,
   local_site: &LocalSite,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<(), LemmyError> {
   if (local_site.registration_mode == RegistrationMode::RequireApplication
     || local_site.registration_mode == RegistrationMode::Closed)
@@ -529,7 +530,7 @@ pub fn check_private_instance_and_federation_enabled(
 
 pub async fn purge_image_posts_for_person(
   banned_person_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
   client: &ClientWithMiddleware,
 ) -> Result<(), LemmyError> {
@@ -552,7 +553,7 @@ pub async fn purge_image_posts_for_person(
 
 pub async fn purge_image_posts_for_community(
   banned_community_id: CommunityId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
   client: &ClientWithMiddleware,
 ) -> Result<(), LemmyError> {
@@ -575,7 +576,7 @@ pub async fn purge_image_posts_for_community(
 
 pub async fn remove_user_data(
   banned_person_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
   client: &ClientWithMiddleware,
 ) -> Result<(), LemmyError> {
@@ -659,7 +660,7 @@ pub async fn remove_user_data(
 pub async fn remove_user_data_in_community(
   community_id: CommunityId,
   banned_person_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<(), LemmyError> {
   // Posts
   Post::update_removed_for_creator(pool, banned_person_id, Some(community_id), true).await?;
@@ -689,7 +690,7 @@ pub async fn remove_user_data_in_community(
 
 pub async fn delete_user_account(
   person_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
   client: &ClientWithMiddleware,
 ) -> Result<(), LemmyError> {
diff --git a/crates/api_crud/src/comment/create.rs b/crates/api_crud/src/comment/create.rs
index 1bcc78483..a05e8dcc7 100644
--- a/crates/api_crud/src/comment/create.rs
+++ b/crates/api_crud/src/comment/create.rs
@@ -43,7 +43,7 @@ impl PerformCrud for CreateComment {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
     let data: &CreateComment = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let content_slurs_removed = remove_slurs(
       &data.content.clone(),
@@ -53,11 +53,11 @@ impl PerformCrud for CreateComment {
 
     // Check for a community ban
     let post_id = data.post_id;
-    let post = get_post(post_id, context.pool()).await?;
+    let post = get_post(post_id, &mut context.pool()).await?;
     let community_id = post.community_id;
 
-    check_community_ban(local_user_view.person.id, community_id, context.pool()).await?;
-    check_community_deleted_or_removed(community_id, context.pool()).await?;
+    check_community_ban(local_user_view.person.id, community_id, &mut context.pool()).await?;
+    check_community_deleted_or_removed(community_id, &mut context.pool()).await?;
     check_post_deleted_or_removed(&post)?;
 
     // Check if post is locked, no new comments
@@ -67,7 +67,7 @@ impl PerformCrud for CreateComment {
 
     // Fetch the parent, if it exists
     let parent_opt = if let Some(parent_id) = data.parent_id {
-      Comment::read(context.pool(), parent_id).await.ok()
+      Comment::read(&mut context.pool(), parent_id).await.ok()
     } else {
       None
     };
@@ -89,7 +89,7 @@ impl PerformCrud for CreateComment {
     let language_id = data.language_id.unwrap_or(parent_language);
 
     CommunityLanguage::is_allowed_community_language(
-      context.pool(),
+      &mut context.pool(),
       Some(language_id),
       community_id,
     )
@@ -104,9 +104,10 @@ impl PerformCrud for CreateComment {
 
     // Create the comment
     let parent_path = parent_opt.clone().map(|t| t.path);
-    let inserted_comment = Comment::create(context.pool(), &comment_form, parent_path.as_ref())
-      .await
-      .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_comment"))?;
+    let inserted_comment =
+      Comment::create(&mut context.pool(), &comment_form, parent_path.as_ref())
+        .await
+        .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_comment"))?;
 
     // Necessary to update the ap_id
     let inserted_comment_id = inserted_comment.id;
@@ -118,7 +119,7 @@ impl PerformCrud for CreateComment {
       &protocol_and_hostname,
     )?;
     let updated_comment = Comment::update(
-      context.pool(),
+      &mut context.pool(),
       inserted_comment_id,
       &CommentUpdateForm::builder().ap_id(Some(apub_id)).build(),
     )
@@ -145,17 +146,17 @@ impl PerformCrud for CreateComment {
       score: 1,
     };
 
-    CommentLike::like(context.pool(), &like_form)
+    CommentLike::like(&mut context.pool(), &like_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?;
 
     // If its a reply, mark the parent as read
     if let Some(parent) = parent_opt {
       let parent_id = parent.id;
-      let comment_reply = CommentReply::read_by_comment(context.pool(), parent_id).await;
+      let comment_reply = CommentReply::read_by_comment(&mut context.pool(), parent_id).await;
       if let Ok(reply) = comment_reply {
         CommentReply::update(
-          context.pool(),
+          &mut context.pool(),
           reply.id,
           &CommentReplyUpdateForm { read: Some(true) },
         )
@@ -166,10 +167,10 @@ impl PerformCrud for CreateComment {
       // If the parent has PersonMentions mark them as read too
       let person_id = local_user_view.person.id;
       let person_mention =
-        PersonMention::read_by_comment_and_person(context.pool(), parent_id, person_id).await;
+        PersonMention::read_by_comment_and_person(&mut context.pool(), parent_id, person_id).await;
       if let Ok(mention) = person_mention {
         PersonMention::update(
-          context.pool(),
+          &mut context.pool(),
           mention.id,
           &PersonMentionUpdateForm { read: Some(true) },
         )
diff --git a/crates/api_crud/src/comment/delete.rs b/crates/api_crud/src/comment/delete.rs
index 864daded8..2874d8553 100644
--- a/crates/api_crud/src/comment/delete.rs
+++ b/crates/api_crud/src/comment/delete.rs
@@ -26,7 +26,7 @@ impl PerformCrud for DeleteComment {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let comment_id = data.comment_id;
-    let orig_comment = CommentView::read(context.pool(), comment_id, None).await?;
+    let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
     // Dont delete it if its already been deleted.
     if orig_comment.comment.deleted == data.deleted {
@@ -36,7 +36,7 @@ impl PerformCrud for DeleteComment {
     check_community_ban(
       local_user_view.person.id,
       orig_comment.community.id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
@@ -48,7 +48,7 @@ impl PerformCrud for DeleteComment {
     // Do the delete
     let deleted = data.deleted;
     let updated_comment = Comment::update(
-      context.pool(),
+      &mut context.pool(),
       comment_id,
       &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
     )
@@ -56,7 +56,7 @@ impl PerformCrud for DeleteComment {
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 
     let post_id = updated_comment.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
     let recipient_ids = send_local_notifs(
       vec![],
       &updated_comment,
diff --git a/crates/api_crud/src/comment/read.rs b/crates/api_crud/src/comment/read.rs
index 2ae719738..e6899fdc7 100644
--- a/crates/api_crud/src/comment/read.rs
+++ b/crates/api_crud/src/comment/read.rs
@@ -17,7 +17,7 @@ impl PerformCrud for GetComment {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
     let data = self;
     let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     check_private_instance(&local_user_view, &local_site)?;
 
diff --git a/crates/api_crud/src/comment/remove.rs b/crates/api_crud/src/comment/remove.rs
index 6e4e55281..ccae4830e 100644
--- a/crates/api_crud/src/comment/remove.rs
+++ b/crates/api_crud/src/comment/remove.rs
@@ -27,18 +27,18 @@ impl PerformCrud for RemoveComment {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let comment_id = data.comment_id;
-    let orig_comment = CommentView::read(context.pool(), comment_id, None).await?;
+    let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_comment.community.id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
     // Verify that only a mod or admin can remove
     is_mod_or_admin(
-      context.pool(),
+      &mut context.pool(),
       local_user_view.person.id,
       orig_comment.community.id,
     )
@@ -47,7 +47,7 @@ impl PerformCrud for RemoveComment {
     // Do the remove
     let removed = data.removed;
     let updated_comment = Comment::update(
-      context.pool(),
+      &mut context.pool(),
       comment_id,
       &CommentUpdateForm::builder().removed(Some(removed)).build(),
     )
@@ -61,10 +61,10 @@ impl PerformCrud for RemoveComment {
       removed: Some(removed),
       reason: data.reason.clone(),
     };
-    ModRemoveComment::create(context.pool(), &form).await?;
+    ModRemoveComment::create(&mut context.pool(), &form).await?;
 
     let post_id = updated_comment.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
     let recipient_ids = send_local_notifs(
       vec![],
       &updated_comment,
diff --git a/crates/api_crud/src/comment/update.rs b/crates/api_crud/src/comment/update.rs
index 3504e784d..62d5dbb7e 100644
--- a/crates/api_crud/src/comment/update.rs
+++ b/crates/api_crud/src/comment/update.rs
@@ -33,15 +33,15 @@ impl PerformCrud for EditComment {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
     let data: &EditComment = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let comment_id = data.comment_id;
-    let orig_comment = CommentView::read(context.pool(), comment_id, None).await?;
+    let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_comment.community.id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
@@ -52,7 +52,7 @@ impl PerformCrud for EditComment {
 
     let language_id = self.language_id;
     CommunityLanguage::is_allowed_community_language(
-      context.pool(),
+      &mut context.pool(),
       language_id,
       orig_comment.community.id,
     )
@@ -72,7 +72,7 @@ impl PerformCrud for EditComment {
       .language_id(data.language_id)
       .updated(Some(Some(naive_now())))
       .build();
-    let updated_comment = Comment::update(context.pool(), comment_id, &form)
+    let updated_comment = Comment::update(&mut context.pool(), comment_id, &form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 
diff --git a/crates/api_crud/src/community/create.rs b/crates/api_crud/src/community/create.rs
index 0e55beac9..c69c8d47c 100644
--- a/crates/api_crud/src/community/create.rs
+++ b/crates/api_crud/src/community/create.rs
@@ -48,7 +48,7 @@ impl PerformCrud for CreateCommunity {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
     let data: &CreateCommunity = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
     let local_site = site_view.local_site;
 
     if local_site.community_creation_admin_only && is_admin(&local_user_view).is_err() {
@@ -75,7 +75,8 @@ impl PerformCrud for CreateCommunity {
       &data.name,
       &context.settings().get_protocol_and_hostname(),
     )?;
-    let community_dupe = Community::read_from_apub_id(context.pool(), &community_actor_id).await?;
+    let community_dupe =
+      Community::read_from_apub_id(&mut context.pool(), &community_actor_id).await?;
     if community_dupe.is_some() {
       return Err(LemmyError::from_message("community_already_exists"));
     }
@@ -100,7 +101,7 @@ impl PerformCrud for CreateCommunity {
       .instance_id(site_view.site.instance_id)
       .build();
 
-    let inserted_community = Community::create(context.pool(), &community_form)
+    let inserted_community = Community::create(&mut context.pool(), &community_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "community_already_exists"))?;
 
@@ -110,7 +111,7 @@ impl PerformCrud for CreateCommunity {
       person_id: local_user_view.person.id,
     };
 
-    CommunityModerator::join(context.pool(), &community_moderator_form)
+    CommunityModerator::join(&mut context.pool(), &community_moderator_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
 
@@ -121,21 +122,21 @@ impl PerformCrud for CreateCommunity {
       pending: false,
     };
 
-    CommunityFollower::follow(context.pool(), &community_follower_form)
+    CommunityFollower::follow(&mut context.pool(), &community_follower_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
 
     // Update the discussion_languages if that's provided
     let community_id = inserted_community.id;
     if let Some(languages) = data.discussion_languages.clone() {
-      let site_languages = SiteLanguage::read_local_raw(context.pool()).await?;
+      let site_languages = SiteLanguage::read_local_raw(&mut context.pool()).await?;
       // check that community languages are a subset of site languages
       // https://stackoverflow.com/a/64227550
       let is_subset = languages.iter().all(|item| site_languages.contains(item));
       if !is_subset {
         return Err(LemmyError::from_message("language_not_allowed"));
       }
-      CommunityLanguage::update(context.pool(), languages, community_id).await?;
+      CommunityLanguage::update(&mut context.pool(), languages, community_id).await?;
     }
 
     build_community_response(context, local_user_view, community_id).await
diff --git a/crates/api_crud/src/community/delete.rs b/crates/api_crud/src/community/delete.rs
index 019e9f1da..f5eb1ecb2 100644
--- a/crates/api_crud/src/community/delete.rs
+++ b/crates/api_crud/src/community/delete.rs
@@ -25,7 +25,7 @@ impl PerformCrud for DeleteCommunity {
     // Fetch the community mods
     let community_id = data.community_id;
     let community_mods =
-      CommunityModeratorView::for_community(context.pool(), community_id).await?;
+      CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
 
     // Make sure deleter is the top mod
     is_top_mod(&local_user_view, &community_mods)?;
@@ -34,7 +34,7 @@ impl PerformCrud for DeleteCommunity {
     let community_id = data.community_id;
     let deleted = data.deleted;
     Community::update(
-      context.pool(),
+      &mut context.pool(),
       community_id,
       &CommunityUpdateForm::builder()
         .deleted(Some(deleted))
diff --git a/crates/api_crud/src/community/list.rs b/crates/api_crud/src/community/list.rs
index d37dd2dc2..80ad6129c 100644
--- a/crates/api_crud/src/community/list.rs
+++ b/crates/api_crud/src/community/list.rs
@@ -20,7 +20,7 @@ impl PerformCrud for ListCommunities {
   ) -> Result<ListCommunitiesResponse, LemmyError> {
     let data: &ListCommunities = self;
     let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
     let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
 
     check_private_instance(&local_user_view, &local_site)?;
@@ -32,7 +32,7 @@ impl PerformCrud for ListCommunities {
     let limit = data.limit;
     let local_user = local_user_view.map(|l| l.local_user);
     let communities = CommunityQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .listing_type(listing_type)
       .show_nsfw(show_nsfw)
       .sort(sort)
diff --git a/crates/api_crud/src/community/remove.rs b/crates/api_crud/src/community/remove.rs
index 52a503c45..2b385e9b3 100644
--- a/crates/api_crud/src/community/remove.rs
+++ b/crates/api_crud/src/community/remove.rs
@@ -31,7 +31,7 @@ impl PerformCrud for RemoveCommunity {
     let community_id = data.community_id;
     let removed = data.removed;
     Community::update(
-      context.pool(),
+      &mut context.pool(),
       community_id,
       &CommunityUpdateForm::builder()
         .removed(Some(removed))
@@ -49,7 +49,7 @@ impl PerformCrud for RemoveCommunity {
       reason: data.reason.clone(),
       expires,
     };
-    ModRemoveCommunity::create(context.pool(), &form).await?;
+    ModRemoveCommunity::create(&mut context.pool(), &form).await?;
 
     build_community_response(context, local_user_view, community_id).await
   }
diff --git a/crates/api_crud/src/community/update.rs b/crates/api_crud/src/community/update.rs
index dec62865f..81ef6f2ce 100644
--- a/crates/api_crud/src/community/update.rs
+++ b/crates/api_crud/src/community/update.rs
@@ -30,7 +30,7 @@ impl PerformCrud for EditCommunity {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
     let data: &EditCommunity = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let icon = diesel_option_overwrite_to_url(&data.icon)?;
     let banner = diesel_option_overwrite_to_url(&data.banner)?;
@@ -43,23 +43,24 @@ impl PerformCrud for EditCommunity {
 
     // Verify its a mod (only mods can edit it)
     let community_id = data.community_id;
-    let mods: Vec<PersonId> = CommunityModeratorView::for_community(context.pool(), community_id)
-      .await
-      .map(|v| v.into_iter().map(|m| m.moderator.id).collect())?;
+    let mods: Vec<PersonId> =
+      CommunityModeratorView::for_community(&mut context.pool(), community_id)
+        .await
+        .map(|v| v.into_iter().map(|m| m.moderator.id).collect())?;
     if !mods.contains(&local_user_view.person.id) {
       return Err(LemmyError::from_message("not_a_moderator"));
     }
 
     let community_id = data.community_id;
     if let Some(languages) = data.discussion_languages.clone() {
-      let site_languages = SiteLanguage::read_local_raw(context.pool()).await?;
+      let site_languages = SiteLanguage::read_local_raw(&mut context.pool()).await?;
       // check that community languages are a subset of site languages
       // https://stackoverflow.com/a/64227550
       let is_subset = languages.iter().all(|item| site_languages.contains(item));
       if !is_subset {
         return Err(LemmyError::from_message("language_not_allowed"));
       }
-      CommunityLanguage::update(context.pool(), languages, community_id).await?;
+      CommunityLanguage::update(&mut context.pool(), languages, community_id).await?;
     }
 
     let community_form = CommunityUpdateForm::builder()
@@ -73,7 +74,7 @@ impl PerformCrud for EditCommunity {
       .build();
 
     let community_id = data.community_id;
-    Community::update(context.pool(), community_id, &community_form)
+    Community::update(&mut context.pool(), community_id, &community_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community"))?;
 
diff --git a/crates/api_crud/src/custom_emoji/create.rs b/crates/api_crud/src/custom_emoji/create.rs
index 5aaf56125..dcf4fe7f9 100644
--- a/crates/api_crud/src/custom_emoji/create.rs
+++ b/crates/api_crud/src/custom_emoji/create.rs
@@ -22,7 +22,7 @@ impl PerformCrud for CreateCustomEmoji {
     let data: &CreateCustomEmoji = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
     // Make sure user is an admin
     is_admin(&local_user_view)?;
 
@@ -33,7 +33,7 @@ impl PerformCrud for CreateCustomEmoji {
       .category(data.category.to_string())
       .image_url(data.clone().image_url.into())
       .build();
-    let emoji = CustomEmoji::create(context.pool(), &emoji_form).await?;
+    let emoji = CustomEmoji::create(&mut context.pool(), &emoji_form).await?;
     let mut keywords = vec![];
     for keyword in &data.keywords {
       let keyword_form = CustomEmojiKeywordInsertForm::builder()
@@ -42,8 +42,8 @@ impl PerformCrud for CreateCustomEmoji {
         .build();
       keywords.push(keyword_form);
     }
-    CustomEmojiKeyword::create(context.pool(), keywords).await?;
-    let view = CustomEmojiView::get(context.pool(), emoji.id).await?;
+    CustomEmojiKeyword::create(&mut context.pool(), keywords).await?;
+    let view = CustomEmojiView::get(&mut context.pool(), emoji.id).await?;
     Ok(CustomEmojiResponse { custom_emoji: view })
   }
 }
diff --git a/crates/api_crud/src/custom_emoji/delete.rs b/crates/api_crud/src/custom_emoji/delete.rs
index 45dc6eaee..069129239 100644
--- a/crates/api_crud/src/custom_emoji/delete.rs
+++ b/crates/api_crud/src/custom_emoji/delete.rs
@@ -22,7 +22,7 @@ impl PerformCrud for DeleteCustomEmoji {
 
     // Make sure user is an admin
     is_admin(&local_user_view)?;
-    CustomEmoji::delete(context.pool(), data.id).await?;
+    CustomEmoji::delete(&mut context.pool(), data.id).await?;
     Ok(DeleteCustomEmojiResponse {
       id: data.id,
       success: true,
diff --git a/crates/api_crud/src/custom_emoji/update.rs b/crates/api_crud/src/custom_emoji/update.rs
index f56763e9d..7db3a5282 100644
--- a/crates/api_crud/src/custom_emoji/update.rs
+++ b/crates/api_crud/src/custom_emoji/update.rs
@@ -22,7 +22,7 @@ impl PerformCrud for EditCustomEmoji {
     let data: &EditCustomEmoji = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
     // Make sure user is an admin
     is_admin(&local_user_view)?;
 
@@ -32,8 +32,8 @@ impl PerformCrud for EditCustomEmoji {
       .category(data.category.to_string())
       .image_url(data.clone().image_url.into())
       .build();
-    let emoji = CustomEmoji::update(context.pool(), data.id, &emoji_form).await?;
-    CustomEmojiKeyword::delete(context.pool(), data.id).await?;
+    let emoji = CustomEmoji::update(&mut context.pool(), data.id, &emoji_form).await?;
+    CustomEmojiKeyword::delete(&mut context.pool(), data.id).await?;
     let mut keywords = vec![];
     for keyword in &data.keywords {
       let keyword_form = CustomEmojiKeywordInsertForm::builder()
@@ -42,8 +42,8 @@ impl PerformCrud for EditCustomEmoji {
         .build();
       keywords.push(keyword_form);
     }
-    CustomEmojiKeyword::create(context.pool(), keywords).await?;
-    let view = CustomEmojiView::get(context.pool(), emoji.id).await?;
+    CustomEmojiKeyword::create(&mut context.pool(), keywords).await?;
+    let view = CustomEmojiView::get(&mut context.pool(), emoji.id).await?;
     Ok(CustomEmojiResponse { custom_emoji: view })
   }
 }
diff --git a/crates/api_crud/src/post/create.rs b/crates/api_crud/src/post/create.rs
index 1dcc90241..2ba39f996 100644
--- a/crates/api_crud/src/post/create.rs
+++ b/crates/api_crud/src/post/create.rs
@@ -46,7 +46,7 @@ impl PerformCrud for CreatePost {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &CreatePost = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let slur_regex = local_site_to_slur_regex(&local_site);
     check_slurs(&data.name, &slur_regex)?;
@@ -59,15 +59,20 @@ impl PerformCrud for CreatePost {
     is_valid_post_title(&data.name)?;
     is_valid_body_field(&data.body, true)?;
 
-    check_community_ban(local_user_view.person.id, data.community_id, context.pool()).await?;
-    check_community_deleted_or_removed(data.community_id, context.pool()).await?;
+    check_community_ban(
+      local_user_view.person.id,
+      data.community_id,
+      &mut context.pool(),
+    )
+    .await?;
+    check_community_deleted_or_removed(data.community_id, &mut context.pool()).await?;
 
     let community_id = data.community_id;
-    let community = Community::read(context.pool(), community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
     if community.posting_restricted_to_mods {
       let community_id = data.community_id;
       let is_mod = CommunityView::is_mod_or_admin(
-        context.pool(),
+        &mut context.pool(),
         local_user_view.local_user.person_id,
         community_id,
       )
@@ -87,11 +92,20 @@ impl PerformCrud for CreatePost {
     let language_id = match data.language_id {
       Some(lid) => Some(lid),
       None => {
-        default_post_language(context.pool(), community_id, local_user_view.local_user.id).await?
+        default_post_language(
+          &mut context.pool(),
+          community_id,
+          local_user_view.local_user.id,
+        )
+        .await?
       }
     };
-    CommunityLanguage::is_allowed_community_language(context.pool(), language_id, community_id)
-      .await?;
+    CommunityLanguage::is_allowed_community_language(
+      &mut context.pool(),
+      language_id,
+      community_id,
+    )
+    .await?;
 
     let post_form = PostInsertForm::builder()
       .name(data.name.trim().to_owned())
@@ -107,7 +121,7 @@ impl PerformCrud for CreatePost {
       .thumbnail_url(thumbnail_url)
       .build();
 
-    let inserted_post = Post::create(context.pool(), &post_form)
+    let inserted_post = Post::create(&mut context.pool(), &post_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_post"))?;
 
@@ -119,7 +133,7 @@ impl PerformCrud for CreatePost {
       &protocol_and_hostname,
     )?;
     let updated_post = Post::update(
-      context.pool(),
+      &mut context.pool(),
       inserted_post_id,
       &PostUpdateForm::builder().ap_id(Some(apub_id)).build(),
     )
@@ -135,12 +149,12 @@ impl PerformCrud for CreatePost {
       score: 1,
     };
 
-    PostLike::like(context.pool(), &like_form)
+    PostLike::like(&mut context.pool(), &like_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?;
 
     // Mark the post as read
-    mark_post_as_read(person_id, post_id, context.pool()).await?;
+    mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
 
     if let Some(url) = &updated_post.url {
       let mut webmention =
diff --git a/crates/api_crud/src/post/delete.rs b/crates/api_crud/src/post/delete.rs
index 6e6a4c076..4f46a4f5c 100644
--- a/crates/api_crud/src/post/delete.rs
+++ b/crates/api_crud/src/post/delete.rs
@@ -22,7 +22,7 @@ impl PerformCrud for DeletePost {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
-    let orig_post = Post::read(context.pool(), post_id).await?;
+    let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
     // Dont delete it if its already been deleted.
     if orig_post.deleted == data.deleted {
@@ -32,10 +32,10 @@ impl PerformCrud for DeletePost {
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
-    check_community_deleted_or_removed(orig_post.community_id, context.pool()).await?;
+    check_community_deleted_or_removed(orig_post.community_id, &mut context.pool()).await?;
 
     // Verify that only the creator can delete
     if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) {
@@ -46,7 +46,7 @@ impl PerformCrud for DeletePost {
     let post_id = data.post_id;
     let deleted = data.deleted;
     Post::update(
-      context.pool(),
+      &mut context.pool(),
       post_id,
       &PostUpdateForm::builder().deleted(Some(deleted)).build(),
     )
diff --git a/crates/api_crud/src/post/read.rs b/crates/api_crud/src/post/read.rs
index d1851f33e..e0d91a903 100644
--- a/crates/api_crud/src/post/read.rs
+++ b/crates/api_crud/src/post/read.rs
@@ -27,7 +27,7 @@ impl PerformCrud for GetPost {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetPostResponse, LemmyError> {
     let data: &GetPost = self;
     let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     check_private_instance(&local_user_view, &local_site)?;
 
@@ -37,7 +37,7 @@ impl PerformCrud for GetPost {
     let post_id = if let Some(id) = data.id {
       id
     } else if let Some(comment_id) = data.comment_id {
-      Comment::read(context.pool(), comment_id)
+      Comment::read(&mut context.pool(), comment_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?
         .post_id
@@ -46,25 +46,33 @@ impl PerformCrud for GetPost {
     };
 
     // Check to see if the person is a mod or admin, to show deleted / removed
-    let community_id = Post::read(context.pool(), post_id).await?.community_id;
-    let is_mod_or_admin =
-      is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), Some(community_id))
-        .await
-        .is_ok();
+    let community_id = Post::read(&mut context.pool(), post_id).await?.community_id;
+    let is_mod_or_admin = is_mod_or_admin_opt(
+      &mut context.pool(),
+      local_user_view.as_ref(),
+      Some(community_id),
+    )
+    .await
+    .is_ok();
 
-    let post_view = PostView::read(context.pool(), post_id, person_id, Some(is_mod_or_admin))
-      .await
-      .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
+    let post_view = PostView::read(
+      &mut context.pool(),
+      post_id,
+      person_id,
+      Some(is_mod_or_admin),
+    )
+    .await
+    .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
 
     // Mark the post as read
     let post_id = post_view.post.id;
     if let Some(person_id) = person_id {
-      mark_post_as_read(person_id, post_id, context.pool()).await?;
+      mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
     }
 
     // Necessary for the sidebar subscribed
     let community_view = CommunityView::read(
-      context.pool(),
+      &mut context.pool(),
       community_id,
       person_id,
       Some(is_mod_or_admin),
@@ -82,17 +90,18 @@ impl PerformCrud for GetPost {
         read_comments,
         ..PersonPostAggregatesForm::default()
       };
-      PersonPostAggregates::upsert(context.pool(), &person_post_agg_form)
+      PersonPostAggregates::upsert(&mut context.pool(), &person_post_agg_form)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
     }
 
-    let moderators = CommunityModeratorView::for_community(context.pool(), community_id).await?;
+    let moderators =
+      CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
 
     // Fetch the cross_posts
     let cross_posts = if let Some(url) = &post_view.post.url {
       let mut x_posts = PostQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .url_search(Some(url.inner().as_str().into()))
         .build()
         .list()
diff --git a/crates/api_crud/src/post/remove.rs b/crates/api_crud/src/post/remove.rs
index 7f379169e..7950d5047 100644
--- a/crates/api_crud/src/post/remove.rs
+++ b/crates/api_crud/src/post/remove.rs
@@ -25,18 +25,18 @@ impl PerformCrud for RemovePost {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
-    let orig_post = Post::read(context.pool(), post_id).await?;
+    let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
     // Verify that only the mods can remove
     is_mod_or_admin(
-      context.pool(),
+      &mut context.pool(),
       local_user_view.person.id,
       orig_post.community_id,
     )
@@ -46,7 +46,7 @@ impl PerformCrud for RemovePost {
     let post_id = data.post_id;
     let removed = data.removed;
     Post::update(
-      context.pool(),
+      &mut context.pool(),
       post_id,
       &PostUpdateForm::builder().removed(Some(removed)).build(),
     )
@@ -59,7 +59,7 @@ impl PerformCrud for RemovePost {
       removed: Some(removed),
       reason: data.reason.clone(),
     };
-    ModRemovePost::create(context.pool(), &form).await?;
+    ModRemovePost::create(&mut context.pool(), &form).await?;
 
     build_post_response(
       context,
diff --git a/crates/api_crud/src/post/update.rs b/crates/api_crud/src/post/update.rs
index 632bc5ae7..e8d71380d 100644
--- a/crates/api_crud/src/post/update.rs
+++ b/crates/api_crud/src/post/update.rs
@@ -32,7 +32,7 @@ impl PerformCrud for EditPost {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &EditPost = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let data_url = data.url.as_ref();
 
@@ -52,12 +52,12 @@ impl PerformCrud for EditPost {
     is_valid_body_field(&data.body, true)?;
 
     let post_id = data.post_id;
-    let orig_post = Post::read(context.pool(), post_id).await?;
+    let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
-      context.pool(),
+      &mut context.pool(),
     )
     .await?;
 
@@ -76,7 +76,7 @@ impl PerformCrud for EditPost {
 
     let language_id = self.language_id;
     CommunityLanguage::is_allowed_community_language(
-      context.pool(),
+      &mut context.pool(),
       language_id,
       orig_post.community_id,
     )
@@ -96,7 +96,7 @@ impl PerformCrud for EditPost {
       .build();
 
     let post_id = data.post_id;
-    Post::update(context.pool(), post_id, &post_form)
+    Post::update(&mut context.pool(), post_id, &post_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_post"))?;
 
diff --git a/crates/api_crud/src/private_message/create.rs b/crates/api_crud/src/private_message/create.rs
index e1a855463..8f7eec33c 100644
--- a/crates/api_crud/src/private_message/create.rs
+++ b/crates/api_crud/src/private_message/create.rs
@@ -37,7 +37,7 @@ impl PerformCrud for CreatePrivateMessage {
   ) -> Result<PrivateMessageResponse, LemmyError> {
     let data: &CreatePrivateMessage = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let content_slurs_removed = remove_slurs(
       &data.content.clone(),
@@ -45,7 +45,12 @@ impl PerformCrud for CreatePrivateMessage {
     );
     is_valid_body_field(&Some(content_slurs_removed.clone()), false)?;
 
-    check_person_block(local_user_view.person.id, data.recipient_id, context.pool()).await?;
+    check_person_block(
+      local_user_view.person.id,
+      data.recipient_id,
+      &mut context.pool(),
+    )
+    .await?;
 
     let private_message_form = PrivateMessageInsertForm::builder()
       .content(content_slurs_removed.clone())
@@ -54,7 +59,7 @@ impl PerformCrud for CreatePrivateMessage {
       .build();
 
     let inserted_private_message =
-      match PrivateMessage::create(context.pool(), &private_message_form).await {
+      match PrivateMessage::create(&mut context.pool(), &private_message_form).await {
         Ok(private_message) => private_message,
         Err(e) => {
           return Err(LemmyError::from_error_message(
@@ -72,7 +77,7 @@ impl PerformCrud for CreatePrivateMessage {
       &protocol_and_hostname,
     )?;
     PrivateMessage::update(
-      context.pool(),
+      &mut context.pool(),
       inserted_private_message.id,
       &PrivateMessageUpdateForm::builder()
         .ap_id(Some(apub_id))
@@ -81,12 +86,12 @@ impl PerformCrud for CreatePrivateMessage {
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_private_message"))?;
 
-    let view = PrivateMessageView::read(context.pool(), inserted_private_message.id).await?;
+    let view = PrivateMessageView::read(&mut context.pool(), inserted_private_message.id).await?;
 
     // Send email to the local recipient, if one exists
     if view.recipient.local {
       let recipient_id = data.recipient_id;
-      let local_recipient = LocalUserView::read_person(context.pool(), recipient_id).await?;
+      let local_recipient = LocalUserView::read_person(&mut context.pool(), recipient_id).await?;
       let lang = get_interface_language(&local_recipient);
       let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
       let sender_name = &local_user_view.person.name;
diff --git a/crates/api_crud/src/private_message/delete.rs b/crates/api_crud/src/private_message/delete.rs
index b8e3c3b11..888b0d45d 100644
--- a/crates/api_crud/src/private_message/delete.rs
+++ b/crates/api_crud/src/private_message/delete.rs
@@ -26,7 +26,8 @@ impl PerformCrud for DeletePrivateMessage {
 
     // Checking permissions
     let private_message_id = data.private_message_id;
-    let orig_private_message = PrivateMessage::read(context.pool(), private_message_id).await?;
+    let orig_private_message =
+      PrivateMessage::read(&mut context.pool(), private_message_id).await?;
     if local_user_view.person.id != orig_private_message.creator_id {
       return Err(LemmyError::from_message("no_private_message_edit_allowed"));
     }
@@ -35,7 +36,7 @@ impl PerformCrud for DeletePrivateMessage {
     let private_message_id = data.private_message_id;
     let deleted = data.deleted;
     PrivateMessage::update(
-      context.pool(),
+      &mut context.pool(),
       private_message_id,
       &PrivateMessageUpdateForm::builder()
         .deleted(Some(deleted))
@@ -44,7 +45,7 @@ impl PerformCrud for DeletePrivateMessage {
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
 
-    let view = PrivateMessageView::read(context.pool(), private_message_id).await?;
+    let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
     Ok(PrivateMessageResponse {
       private_message_view: view,
     })
diff --git a/crates/api_crud/src/private_message/read.rs b/crates/api_crud/src/private_message/read.rs
index 679cd09f7..73ce034e9 100644
--- a/crates/api_crud/src/private_message/read.rs
+++ b/crates/api_crud/src/private_message/read.rs
@@ -25,7 +25,7 @@ impl PerformCrud for GetPrivateMessages {
     let limit = data.limit;
     let unread_only = data.unread_only;
     let mut messages = PrivateMessageQuery::builder()
-      .pool(context.pool())
+      .pool(&mut context.pool())
       .recipient_id(person_id)
       .page(page)
       .limit(limit)
diff --git a/crates/api_crud/src/private_message/update.rs b/crates/api_crud/src/private_message/update.rs
index b2d8e48f9..d85a86b26 100644
--- a/crates/api_crud/src/private_message/update.rs
+++ b/crates/api_crud/src/private_message/update.rs
@@ -30,11 +30,12 @@ impl PerformCrud for EditPrivateMessage {
   ) -> Result<PrivateMessageResponse, LemmyError> {
     let data: &EditPrivateMessage = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     // Checking permissions
     let private_message_id = data.private_message_id;
-    let orig_private_message = PrivateMessage::read(context.pool(), private_message_id).await?;
+    let orig_private_message =
+      PrivateMessage::read(&mut context.pool(), private_message_id).await?;
     if local_user_view.person.id != orig_private_message.creator_id {
       return Err(LemmyError::from_message("no_private_message_edit_allowed"));
     }
@@ -45,7 +46,7 @@ impl PerformCrud for EditPrivateMessage {
 
     let private_message_id = data.private_message_id;
     PrivateMessage::update(
-      context.pool(),
+      &mut context.pool(),
       private_message_id,
       &PrivateMessageUpdateForm::builder()
         .content(Some(content_slurs_removed))
@@ -55,7 +56,7 @@ impl PerformCrud for EditPrivateMessage {
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
 
-    let view = PrivateMessageView::read(context.pool(), private_message_id).await?;
+    let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
 
     Ok(PrivateMessageResponse {
       private_message_view: view,
diff --git a/crates/api_crud/src/site/create.rs b/crates/api_crud/src/site/create.rs
index 838d5bc40..01ef78d16 100644
--- a/crates/api_crud/src/site/create.rs
+++ b/crates/api_crud/src/site/create.rs
@@ -49,7 +49,7 @@ impl PerformCrud for CreateSite {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> {
     let data: &CreateSite = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let local_site = LocalSite::read(context.pool()).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
 
     // Make sure user is an admin; other types of users should not create site data...
     is_admin(&local_user_view)?;
@@ -74,7 +74,7 @@ impl PerformCrud for CreateSite {
 
     let site_id = local_site.site_id;
 
-    Site::update(context.pool(), site_id, &site_form).await?;
+    Site::update(&mut context.pool(), site_id, &site_form).await?;
 
     let local_site_form = LocalSiteUpdateForm::builder()
       // Set the site setup to true
@@ -99,7 +99,7 @@ impl PerformCrud for CreateSite {
       .captcha_difficulty(data.captcha_difficulty.clone())
       .build();
 
-    LocalSite::update(context.pool(), &local_site_form).await?;
+    LocalSite::update(&mut context.pool(), &local_site_form).await?;
 
     let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder()
       .message(data.rate_limit_message)
@@ -116,12 +116,12 @@ impl PerformCrud for CreateSite {
       .search_per_second(data.rate_limit_search_per_second)
       .build();
 
-    LocalSiteRateLimit::update(context.pool(), &local_site_rate_limit_form).await?;
+    LocalSiteRateLimit::update(&mut context.pool(), &local_site_rate_limit_form).await?;
 
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
 
     let new_taglines = data.taglines.clone();
-    let taglines = Tagline::replace(context.pool(), local_site.id, new_taglines).await?;
+    let taglines = Tagline::replace(&mut context.pool(), local_site.id, new_taglines).await?;
 
     let rate_limit_config =
       local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit);
diff --git a/crates/api_crud/src/site/read.rs b/crates/api_crud/src/site/read.rs
index f6c663ac0..9288dbea4 100644
--- a/crates/api_crud/src/site/read.rs
+++ b/crates/api_crud/src/site/read.rs
@@ -32,9 +32,9 @@ impl PerformCrud for GetSite {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> {
     let data: &GetSite = self;
 
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
 
-    let admins = PersonView::admins(context.pool()).await?;
+    let admins = PersonView::admins(&mut context.pool()).await?;
 
     // Build the local user
     let my_user = if let Some(local_user_view) =
@@ -43,25 +43,25 @@ impl PerformCrud for GetSite {
       let person_id = local_user_view.person.id;
       let local_user_id = local_user_view.local_user.id;
 
-      let follows = CommunityFollowerView::for_person(context.pool(), person_id)
+      let follows = CommunityFollowerView::for_person(&mut context.pool(), person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 
       let person_id = local_user_view.person.id;
-      let community_blocks = CommunityBlockView::for_person(context.pool(), person_id)
+      let community_blocks = CommunityBlockView::for_person(&mut context.pool(), person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 
       let person_id = local_user_view.person.id;
-      let person_blocks = PersonBlockView::for_person(context.pool(), person_id)
+      let person_blocks = PersonBlockView::for_person(&mut context.pool(), person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 
-      let moderates = CommunityModeratorView::for_person(context.pool(), person_id)
+      let moderates = CommunityModeratorView::for_person(&mut context.pool(), person_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 
-      let discussion_languages = LocalUserLanguage::read(context.pool(), local_user_id)
+      let discussion_languages = LocalUserLanguage::read(&mut context.pool(), local_user_id)
         .await
         .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 
@@ -77,10 +77,11 @@ impl PerformCrud for GetSite {
       None
     };
 
-    let all_languages = Language::read_all(context.pool()).await?;
-    let discussion_languages = SiteLanguage::read_local_raw(context.pool()).await?;
-    let taglines = Tagline::get_all(context.pool(), site_view.local_site.id).await?;
-    let custom_emojis = CustomEmojiView::get_all(context.pool(), site_view.local_site.id).await?;
+    let all_languages = Language::read_all(&mut context.pool()).await?;
+    let discussion_languages = SiteLanguage::read_local_raw(&mut context.pool()).await?;
+    let taglines = Tagline::get_all(&mut context.pool(), site_view.local_site.id).await?;
+    let custom_emojis =
+      CustomEmojiView::get_all(&mut context.pool(), site_view.local_site.id).await?;
 
     Ok(GetSiteResponse {
       site_view,
@@ -106,7 +107,7 @@ async fn local_user_settings_view_from_jwt_opt(
         .ok()?
         .claims;
       let local_user_id = LocalUserId(claims.sub);
-      let local_user_view = LocalUserView::read(context.pool(), local_user_id)
+      let local_user_view = LocalUserView::read(&mut context.pool(), local_user_id)
         .await
         .ok()?;
       check_user_valid(
diff --git a/crates/api_crud/src/site/update.rs b/crates/api_crud/src/site/update.rs
index c9f97e8df..c9021b956 100644
--- a/crates/api_crud/src/site/update.rs
+++ b/crates/api_crud/src/site/update.rs
@@ -46,7 +46,7 @@ impl PerformCrud for EditSite {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> {
     let data: &EditSite = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
     let local_site = site_view.local_site;
     let site = site_view.site;
 
@@ -56,7 +56,7 @@ impl PerformCrud for EditSite {
     validate_update_payload(&local_site, data)?;
 
     if let Some(discussion_languages) = data.discussion_languages.clone() {
-      SiteLanguage::update(context.pool(), discussion_languages.clone(), &site).await?;
+      SiteLanguage::update(&mut context.pool(), discussion_languages.clone(), &site).await?;
     }
 
     let site_form = SiteUpdateForm::builder()
@@ -68,7 +68,7 @@ impl PerformCrud for EditSite {
       .updated(Some(Some(naive_now())))
       .build();
 
-    Site::update(context.pool(), site.id, &site_form)
+    Site::update(&mut context.pool(), site.id, &site_form)
       .await
       // Ignore errors for all these, so as to not throw errors if no update occurs
       // Diesel will throw an error for empty update forms
@@ -96,7 +96,7 @@ impl PerformCrud for EditSite {
       .reports_email_admins(data.reports_email_admins)
       .build();
 
-    let update_local_site = LocalSite::update(context.pool(), &local_site_form)
+    let update_local_site = LocalSite::update(&mut context.pool(), &local_site_form)
       .await
       .ok();
 
@@ -115,15 +115,15 @@ impl PerformCrud for EditSite {
       .search_per_second(data.rate_limit_search_per_second)
       .build();
 
-    LocalSiteRateLimit::update(context.pool(), &local_site_rate_limit_form)
+    LocalSiteRateLimit::update(&mut context.pool(), &local_site_rate_limit_form)
       .await
       .ok();
 
     // Replace the blocked and allowed instances
     let allowed = data.allowed_instances.clone();
-    FederationAllowList::replace(context.pool(), allowed).await?;
+    FederationAllowList::replace(&mut context.pool(), allowed).await?;
     let blocked = data.blocked_instances.clone();
-    FederationBlockList::replace(context.pool(), blocked).await?;
+    FederationBlockList::replace(&mut context.pool(), blocked).await?;
 
     // TODO can't think of a better way to do this.
     // If the server suddenly requires email verification, or required applications, no old users
@@ -137,7 +137,7 @@ impl PerformCrud for EditSite {
       .map(|ols| ols.registration_mode == RegistrationMode::RequireApplication)
       .unwrap_or(false);
     if !old_require_application && new_require_application {
-      LocalUser::set_all_users_registration_applications_accepted(context.pool())
+      LocalUser::set_all_users_registration_applications_accepted(&mut context.pool())
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_registrations_accepted"))?;
     }
@@ -147,15 +147,15 @@ impl PerformCrud for EditSite {
       .map(|ols| ols.require_email_verification)
       .unwrap_or(false);
     if !local_site.require_email_verification && new_require_email_verification {
-      LocalUser::set_all_users_email_verified(context.pool())
+      LocalUser::set_all_users_email_verified(&mut context.pool())
         .await
         .map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_email_verified"))?;
     }
 
     let new_taglines = data.taglines.clone();
-    let taglines = Tagline::replace(context.pool(), local_site.id, new_taglines).await?;
+    let taglines = Tagline::replace(&mut context.pool(), local_site.id, new_taglines).await?;
 
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
 
     let rate_limit_config =
       local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit);
diff --git a/crates/api_crud/src/user/create.rs b/crates/api_crud/src/user/create.rs
index 302e2f98e..fc9a63196 100644
--- a/crates/api_crud/src/user/create.rs
+++ b/crates/api_crud/src/user/create.rs
@@ -45,7 +45,7 @@ impl PerformCrud for Register {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
     let data: &Register = self;
 
-    let site_view = SiteView::read_local(context.pool()).await?;
+    let site_view = SiteView::read_local(&mut context.pool()).await?;
     let local_site = site_view.local_site;
     let require_registration_application =
       local_site.registration_mode == RegistrationMode::RequireApplication;
@@ -76,7 +76,7 @@ impl PerformCrud for Register {
       if let Some(captcha_uuid) = &data.captcha_uuid {
         let uuid = uuid::Uuid::parse_str(captcha_uuid)?;
         let check = CaptchaAnswer::check_captcha(
-          context.pool(),
+          &mut context.pool(),
           CheckCaptchaAnswer {
             uuid,
             answer: data.captcha_answer.clone().unwrap_or_default(),
@@ -104,7 +104,7 @@ impl PerformCrud for Register {
     )?;
 
     if let Some(email) = &data.email {
-      if LocalUser::is_email_taken(context.pool(), email).await? {
+      if LocalUser::is_email_taken(&mut context.pool(), email).await? {
         return Err(LemmyError::from_message("email_already_exists"));
       }
     }
@@ -125,7 +125,7 @@ impl PerformCrud for Register {
       .build();
 
     // insert the person
-    let inserted_person = Person::create(context.pool(), &person_form)
+    let inserted_person = Person::create(&mut context.pool(), &person_form)
       .await
       .map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
 
@@ -142,7 +142,7 @@ impl PerformCrud for Register {
       .accepted_application(accepted_application)
       .build();
 
-    let inserted_local_user = LocalUser::create(context.pool(), &local_user_form).await?;
+    let inserted_local_user = LocalUser::create(&mut context.pool(), &local_user_form).await?;
 
     if local_site.site_setup && require_registration_application {
       // Create the registration application
@@ -152,12 +152,12 @@ impl PerformCrud for Register {
         answer: data.answer.clone().expect("must have an answer"),
       };
 
-      RegistrationApplication::create(context.pool(), &form).await?;
+      RegistrationApplication::create(&mut context.pool(), &form).await?;
     }
 
     // Email the admins
     if local_site.application_email_admins {
-      send_new_applicant_email_to_admins(&data.username, context.pool(), context.settings())
+      send_new_applicant_email_to_admins(&data.username, &mut context.pool(), context.settings())
         .await?;
     }
 
@@ -193,8 +193,13 @@ impl PerformCrud for Register {
           .clone()
           .expect("email was provided");
 
-        send_verification_email(&local_user_view, &email, context.pool(), context.settings())
-          .await?;
+        send_verification_email(
+          &local_user_view,
+          &email,
+          &mut context.pool(),
+          context.settings(),
+        )
+        .await?;
         login_response.verify_email_sent = true;
       }
 
diff --git a/crates/apub/src/activities/block/block_user.rs b/crates/apub/src/activities/block/block_user.rs
index 46f9b7940..f8a1e4b8d 100644
--- a/crates/apub/src/activities/block/block_user.rs
+++ b/crates/apub/src/activities/block/block_user.rs
@@ -60,7 +60,7 @@ impl BlockUser {
       actor: mod_.id().into(),
       to: vec![public()],
       object: user.id().into(),
-      cc: generate_cc(target, context.pool()).await?,
+      cc: generate_cc(target, &mut context.pool()).await?,
       target: target.id(),
       kind: BlockType::Block,
       remove_data,
@@ -97,7 +97,7 @@ impl BlockUser {
 
     match target {
       SiteOrCommunity::Site(_) => {
-        let inboxes = remote_instance_inboxes(context.pool()).await?;
+        let inboxes = remote_instance_inboxes(&mut context.pool()).await?;
         send_lemmy_activity(context, block, mod_, inboxes, false).await
       }
       SiteOrCommunity::Community(c) => {
@@ -155,7 +155,7 @@ impl ActivityHandler for BlockUser {
     match target {
       SiteOrCommunity::Site(_site) => {
         let blocked_person = Person::update(
-          context.pool(),
+          &mut context.pool(),
           blocked_person.id,
           &PersonUpdateForm::builder()
             .banned(Some(true))
@@ -166,7 +166,7 @@ impl ActivityHandler for BlockUser {
         if self.remove_data.unwrap_or(false) {
           remove_user_data(
             blocked_person.id,
-            context.pool(),
+            &mut context.pool(),
             context.settings(),
             context.client(),
           )
@@ -181,7 +181,7 @@ impl ActivityHandler for BlockUser {
           banned: Some(true),
           expires,
         };
-        ModBan::create(context.pool(), &form).await?;
+        ModBan::create(&mut context.pool(), &form).await?;
       }
       SiteOrCommunity::Community(community) => {
         let community_user_ban_form = CommunityPersonBanForm {
@@ -189,7 +189,7 @@ impl ActivityHandler for BlockUser {
           person_id: blocked_person.id,
           expires: Some(expires),
         };
-        CommunityPersonBan::ban(context.pool(), &community_user_ban_form).await?;
+        CommunityPersonBan::ban(&mut context.pool(), &community_user_ban_form).await?;
 
         // Also unsubscribe them from the community, if they are subscribed
         let community_follower_form = CommunityFollowerForm {
@@ -197,12 +197,13 @@ impl ActivityHandler for BlockUser {
           person_id: blocked_person.id,
           pending: false,
         };
-        CommunityFollower::unfollow(context.pool(), &community_follower_form)
+        CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
           .await
           .ok();
 
         if self.remove_data.unwrap_or(false) {
-          remove_user_data_in_community(community.id, blocked_person.id, context.pool()).await?;
+          remove_user_data_in_community(community.id, blocked_person.id, &mut context.pool())
+            .await?;
         }
 
         // write to mod log
@@ -214,7 +215,7 @@ impl ActivityHandler for BlockUser {
           banned: Some(true),
           expires,
         };
-        ModBanFromCommunity::create(context.pool(), &form).await?;
+        ModBanFromCommunity::create(&mut context.pool(), &form).await?;
       }
     }
 
diff --git a/crates/apub/src/activities/block/mod.rs b/crates/apub/src/activities/block/mod.rs
index a791ea40e..babc836bf 100644
--- a/crates/apub/src/activities/block/mod.rs
+++ b/crates/apub/src/activities/block/mod.rs
@@ -22,6 +22,7 @@ use lemmy_db_schema::{
   source::{community::Community, person::Person, site::Site},
   traits::Crud,
   utils::DbPool,
+  DbPoolRef,
 };
 use lemmy_db_views::structs::SiteView;
 use lemmy_utils::{error::LemmyError, utils::time::naive_from_unix};
@@ -118,7 +119,10 @@ impl SiteOrCommunity {
   }
 }
 
-async fn generate_cc(target: &SiteOrCommunity, pool: &DbPool) -> Result<Vec<Url>, LemmyError> {
+async fn generate_cc(
+  target: &SiteOrCommunity,
+  pool: DbPoolRef<'_>,
+) -> Result<Vec<Url>, LemmyError> {
   Ok(match target {
     SiteOrCommunity::Site(_) => Site::read_remote_sites(pool)
       .await?
@@ -139,8 +143,8 @@ impl SendActivity for BanPerson {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let person = Person::read(context.pool(), request.person_id).await?;
-    let site = SiteOrCommunity::Site(SiteView::read_local(context.pool()).await?.site.into());
+    let person = Person::read(&mut context.pool(), request.person_id).await?;
+    let site = SiteOrCommunity::Site(SiteView::read_local(&mut context.pool()).await?.site.into());
     let expires = request.expires.map(naive_from_unix);
 
     // if the action affects a local user, federate to other instances
@@ -182,10 +186,10 @@ impl SendActivity for BanFromCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community: ApubCommunity = Community::read(context.pool(), request.community_id)
+    let community: ApubCommunity = Community::read(&mut context.pool(), request.community_id)
       .await?
       .into();
-    let banned_person: ApubPerson = Person::read(context.pool(), request.person_id)
+    let banned_person: ApubPerson = Person::read(&mut context.pool(), request.person_id)
       .await?
       .into();
     let expires = request.expires.map(naive_from_unix);
diff --git a/crates/apub/src/activities/block/undo_block_user.rs b/crates/apub/src/activities/block/undo_block_user.rs
index 43bc73523..b31f8b4b2 100644
--- a/crates/apub/src/activities/block/undo_block_user.rs
+++ b/crates/apub/src/activities/block/undo_block_user.rs
@@ -53,7 +53,7 @@ impl UndoBlockUser {
       actor: mod_.id().into(),
       to: vec![public()],
       object: block,
-      cc: generate_cc(target, context.pool()).await?,
+      cc: generate_cc(target, &mut context.pool()).await?,
       kind: UndoType::Undo,
       id: id.clone(),
       audience,
@@ -62,7 +62,7 @@ impl UndoBlockUser {
     let mut inboxes = vec![user.shared_inbox_or_inbox()];
     match target {
       SiteOrCommunity::Site(_) => {
-        inboxes.append(&mut remote_instance_inboxes(context.pool()).await?);
+        inboxes.append(&mut remote_instance_inboxes(&mut context.pool()).await?);
         send_lemmy_activity(context, undo, mod_, inboxes, false).await
       }
       SiteOrCommunity::Community(c) => {
@@ -103,7 +103,7 @@ impl ActivityHandler for UndoBlockUser {
     match self.object.target.dereference(context).await? {
       SiteOrCommunity::Site(_site) => {
         let blocked_person = Person::update(
-          context.pool(),
+          &mut context.pool(),
           blocked_person.id,
           &PersonUpdateForm::builder()
             .banned(Some(false))
@@ -120,7 +120,7 @@ impl ActivityHandler for UndoBlockUser {
           banned: Some(false),
           expires,
         };
-        ModBan::create(context.pool(), &form).await?;
+        ModBan::create(&mut context.pool(), &form).await?;
       }
       SiteOrCommunity::Community(community) => {
         let community_user_ban_form = CommunityPersonBanForm {
@@ -128,7 +128,7 @@ impl ActivityHandler for UndoBlockUser {
           person_id: blocked_person.id,
           expires: None,
         };
-        CommunityPersonBan::unban(context.pool(), &community_user_ban_form).await?;
+        CommunityPersonBan::unban(&mut context.pool(), &community_user_ban_form).await?;
 
         // write to mod log
         let form = ModBanFromCommunityForm {
@@ -139,7 +139,7 @@ impl ActivityHandler for UndoBlockUser {
           banned: Some(false),
           expires,
         };
-        ModBanFromCommunity::create(context.pool(), &form).await?;
+        ModBanFromCommunity::create(&mut context.pool(), &form).await?;
       }
     }
 
diff --git a/crates/apub/src/activities/community/collection_add.rs b/crates/apub/src/activities/community/collection_add.rs
index be5dd0fe3..d08b0cb48 100644
--- a/crates/apub/src/activities/community/collection_add.rs
+++ b/crates/apub/src/activities/community/collection_add.rs
@@ -119,7 +119,7 @@ impl ActivityHandler for CollectionAdd {
   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     insert_activity(&self.id, &self, false, false, context).await?;
     let (community, collection_type) =
-      Community::get_by_collection_url(context.pool(), &self.target.into()).await?;
+      Community::get_by_collection_url(&mut context.pool(), &self.target.into()).await?;
     match collection_type {
       CollectionType::Moderators => {
         let new_mod = ObjectId::<ApubPerson>::from(self.object)
@@ -130,13 +130,14 @@ impl ActivityHandler for CollectionAdd {
         // been added. Skip it here as it would result in a duplicate key error.
         let new_mod_id = new_mod.id;
         let moderated_communities =
-          CommunityModerator::get_person_moderated_communities(context.pool(), new_mod_id).await?;
+          CommunityModerator::get_person_moderated_communities(&mut context.pool(), new_mod_id)
+            .await?;
         if !moderated_communities.contains(&community.id) {
           let form = CommunityModeratorForm {
             community_id: community.id,
             person_id: new_mod.id,
           };
-          CommunityModerator::join(context.pool(), &form).await?;
+          CommunityModerator::join(&mut context.pool(), &form).await?;
 
           // write mod log
           let actor = self.actor.dereference(context).await?;
@@ -146,7 +147,7 @@ impl ActivityHandler for CollectionAdd {
             community_id: community.id,
             removed: Some(false),
           };
-          ModAddCommunity::create(context.pool(), &form).await?;
+          ModAddCommunity::create(&mut context.pool(), &form).await?;
         }
         // TODO: send websocket notification about added mod
       }
@@ -157,7 +158,7 @@ impl ActivityHandler for CollectionAdd {
         let form = PostUpdateForm::builder()
           .featured_community(Some(true))
           .build();
-        Post::update(context.pool(), post.id, &form).await?;
+        Post::update(&mut context.pool(), post.id, &form).await?;
       }
     }
     Ok(())
@@ -174,10 +175,10 @@ impl SendActivity for AddModToCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community: ApubCommunity = Community::read(context.pool(), request.community_id)
+    let community: ApubCommunity = Community::read(&mut context.pool(), request.community_id)
       .await?
       .into();
-    let updated_mod: ApubPerson = Person::read(context.pool(), request.person_id)
+    let updated_mod: ApubPerson = Person::read(&mut context.pool(), request.person_id)
       .await?
       .into();
     if request.added {
@@ -210,7 +211,7 @@ impl SendActivity for FeaturePost {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), response.post_view.community.id)
+    let community = Community::read(&mut context.pool(), response.post_view.community.id)
       .await?
       .into();
     let post = response.post_view.post.clone().into();
diff --git a/crates/apub/src/activities/community/collection_remove.rs b/crates/apub/src/activities/community/collection_remove.rs
index 8f920cf24..a1c443ea8 100644
--- a/crates/apub/src/activities/community/collection_remove.rs
+++ b/crates/apub/src/activities/community/collection_remove.rs
@@ -112,7 +112,7 @@ impl ActivityHandler for CollectionRemove {
   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     insert_activity(&self.id, &self, false, false, context).await?;
     let (community, collection_type) =
-      Community::get_by_collection_url(context.pool(), &self.target.into()).await?;
+      Community::get_by_collection_url(&mut context.pool(), &self.target.into()).await?;
     match collection_type {
       CollectionType::Moderators => {
         let remove_mod = ObjectId::<ApubPerson>::from(self.object)
@@ -123,7 +123,7 @@ impl ActivityHandler for CollectionRemove {
           community_id: community.id,
           person_id: remove_mod.id,
         };
-        CommunityModerator::leave(context.pool(), &form).await?;
+        CommunityModerator::leave(&mut context.pool(), &form).await?;
 
         // write mod log
         let actor = self.actor.dereference(context).await?;
@@ -133,7 +133,7 @@ impl ActivityHandler for CollectionRemove {
           community_id: community.id,
           removed: Some(true),
         };
-        ModAddCommunity::create(context.pool(), &form).await?;
+        ModAddCommunity::create(&mut context.pool(), &form).await?;
 
         // TODO: send websocket notification about removed mod
       }
@@ -144,7 +144,7 @@ impl ActivityHandler for CollectionRemove {
         let form = PostUpdateForm::builder()
           .featured_community(Some(false))
           .build();
-        Post::update(context.pool(), post.id, &form).await?;
+        Post::update(&mut context.pool(), post.id, &form).await?;
       }
     }
     Ok(())
diff --git a/crates/apub/src/activities/community/lock_page.rs b/crates/apub/src/activities/community/lock_page.rs
index 5e4eefb81..0416b972a 100644
--- a/crates/apub/src/activities/community/lock_page.rs
+++ b/crates/apub/src/activities/community/lock_page.rs
@@ -60,7 +60,7 @@ impl ActivityHandler for LockPage {
   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
     let form = PostUpdateForm::builder().locked(Some(true)).build();
     let post = self.object.dereference(context).await?;
-    Post::update(context.pool(), post.id, &form).await?;
+    Post::update(&mut context.pool(), post.id, &form).await?;
     Ok(())
   }
 }
@@ -97,7 +97,7 @@ impl ActivityHandler for UndoLockPage {
     insert_activity(&self.id, &self, false, false, context).await?;
     let form = PostUpdateForm::builder().locked(Some(false)).build();
     let post = self.object.object.dereference(context).await?;
-    Post::update(context.pool(), post.id, &form).await?;
+    Post::update(&mut context.pool(), post.id, &form).await?;
     Ok(())
   }
 }
@@ -145,7 +145,7 @@ impl SendActivity for LockPost {
       };
       AnnouncableActivities::UndoLockPost(undo)
     };
-    let community = Community::read(context.pool(), response.post_view.community.id).await?;
+    let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
     send_activity_in_community(
       activity,
       &local_user_view.person.into(),
diff --git a/crates/apub/src/activities/community/mod.rs b/crates/apub/src/activities/community/mod.rs
index 010bad4f4..7a88b34b3 100644
--- a/crates/apub/src/activities/community/mod.rs
+++ b/crates/apub/src/activities/community/mod.rs
@@ -44,7 +44,7 @@ pub(crate) async fn send_activity_in_community(
   // send to user followers
   if !is_mod_action {
     inboxes.extend(
-      &mut PersonFollower::list_followers(context.pool(), actor.id)
+      &mut PersonFollower::list_followers(&mut context.pool(), actor.id)
         .await?
         .into_iter()
         .map(|p| ApubPerson(p).shared_inbox_or_inbox()),
diff --git a/crates/apub/src/activities/community/report.rs b/crates/apub/src/activities/community/report.rs
index 750672edb..1dffacc39 100644
--- a/crates/apub/src/activities/community/report.rs
+++ b/crates/apub/src/activities/community/report.rs
@@ -134,7 +134,7 @@ impl ActivityHandler for Report {
           reason: self.summary,
           original_post_body: post.body.clone(),
         };
-        PostReport::report(context.pool(), &report_form).await?;
+        PostReport::report(&mut context.pool(), &report_form).await?;
       }
       PostOrComment::Comment(comment) => {
         let report_form = CommentReportForm {
@@ -143,7 +143,7 @@ impl ActivityHandler for Report {
           original_comment_text: comment.content.clone(),
           reason: self.summary,
         };
-        CommentReport::report(context.pool(), &report_form).await?;
+        CommentReport::report(&mut context.pool(), &report_form).await?;
       }
     };
     Ok(())
diff --git a/crates/apub/src/activities/community/update.rs b/crates/apub/src/activities/community/update.rs
index f8bbfa6ce..3e697fddc 100644
--- a/crates/apub/src/activities/community/update.rs
+++ b/crates/apub/src/activities/community/update.rs
@@ -36,7 +36,7 @@ impl SendActivity for EditCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), request.community_id).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
     UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
   }
 }
@@ -97,7 +97,7 @@ impl ActivityHandler for UpdateCommunity {
 
     let community_update_form = self.object.into_update_form();
 
-    Community::update(context.pool(), community.id, &community_update_form).await?;
+    Community::update(&mut context.pool(), community.id, &community_update_form).await?;
     Ok(())
   }
 }
@@ -112,7 +112,7 @@ impl SendActivity for HideCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), request.community_id).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
     UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
   }
 }
diff --git a/crates/apub/src/activities/create_or_update/comment.rs b/crates/apub/src/activities/create_or_update/comment.rs
index e9e567335..804f1827b 100644
--- a/crates/apub/src/activities/create_or_update/comment.rs
+++ b/crates/apub/src/activities/create_or_update/comment.rs
@@ -91,10 +91,12 @@ impl CreateOrUpdateNote {
   ) -> Result<(), LemmyError> {
     // TODO: might be helpful to add a comment method to retrieve community directly
     let post_id = comment.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
     let community_id = post.community_id;
-    let person: ApubPerson = Person::read(context.pool(), person_id).await?.into();
-    let community: ApubCommunity = Community::read(context.pool(), community_id).await?.into();
+    let person: ApubPerson = Person::read(&mut context.pool(), person_id).await?.into();
+    let community: ApubCommunity = Community::read(&mut context.pool(), community_id)
+      .await?
+      .into();
 
     let id = generate_activity_id(
       kind.clone(),
@@ -177,7 +179,7 @@ impl ActivityHandler for CreateOrUpdateNote {
       if distinguished != existing_comment.distinguished {
         let creator = self.actor.dereference(context).await?;
         let (post, _) = self.object.get_parents(context).await?;
-        is_mod_or_admin(context.pool(), creator.id, post.community_id).await?;
+        is_mod_or_admin(&mut context.pool(), creator.id, post.community_id).await?;
       }
     }
 
@@ -190,14 +192,14 @@ impl ActivityHandler for CreateOrUpdateNote {
       person_id: comment.creator_id,
       score: 1,
     };
-    CommentLike::like(context.pool(), &like_form).await?;
+    CommentLike::like(&mut context.pool(), &like_form).await?;
 
     // Calculate initial hot_rank
-    CommentAggregates::update_hot_rank(context.pool(), comment.id).await?;
+    CommentAggregates::update_hot_rank(&mut context.pool(), comment.id).await?;
 
     let do_send_email = self.kind == CreateOrUpdateType::Create;
     let post_id = comment.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
     let actor = self.actor.dereference(context).await?;
 
     // Note:
diff --git a/crates/apub/src/activities/create_or_update/post.rs b/crates/apub/src/activities/create_or_update/post.rs
index 916111fc5..ea0b7e26d 100644
--- a/crates/apub/src/activities/create_or_update/post.rs
+++ b/crates/apub/src/activities/create_or_update/post.rs
@@ -109,8 +109,10 @@ impl CreateOrUpdatePage {
   ) -> Result<(), LemmyError> {
     let post = ApubPost(post.clone());
     let community_id = post.community_id;
-    let person: ApubPerson = Person::read(context.pool(), person_id).await?.into();
-    let community: ApubCommunity = Community::read(context.pool(), community_id).await?.into();
+    let person: ApubPerson = Person::read(&mut context.pool(), person_id).await?.into();
+    let community: ApubCommunity = Community::read(&mut context.pool(), community_id)
+      .await?
+      .into();
 
     let create_or_update =
       CreateOrUpdatePage::new(post, &person, &community, kind, context).await?;
@@ -187,10 +189,10 @@ impl ActivityHandler for CreateOrUpdatePage {
       person_id: post.creator_id,
       score: 1,
     };
-    PostLike::like(context.pool(), &like_form).await?;
+    PostLike::like(&mut context.pool(), &like_form).await?;
 
     // Calculate initial hot_rank for post
-    PostAggregates::update_hot_rank(context.pool(), post.id).await?;
+    PostAggregates::update_hot_rank(&mut context.pool(), post.id).await?;
 
     Ok(())
   }
diff --git a/crates/apub/src/activities/create_or_update/private_message.rs b/crates/apub/src/activities/create_or_update/private_message.rs
index 691eff300..36c9785da 100644
--- a/crates/apub/src/activities/create_or_update/private_message.rs
+++ b/crates/apub/src/activities/create_or_update/private_message.rs
@@ -71,8 +71,10 @@ impl CreateOrUpdateChatMessage {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let recipient_id = private_message.recipient_id;
-    let sender: ApubPerson = Person::read(context.pool(), sender_id).await?.into();
-    let recipient: ApubPerson = Person::read(context.pool(), recipient_id).await?.into();
+    let sender: ApubPerson = Person::read(&mut context.pool(), sender_id).await?.into();
+    let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
+      .await?
+      .into();
 
     let id = generate_activity_id(
       kind.clone(),
diff --git a/crates/apub/src/activities/deletion/delete.rs b/crates/apub/src/activities/deletion/delete.rs
index dfa709c36..4bfba2a77 100644
--- a/crates/apub/src/activities/deletion/delete.rs
+++ b/crates/apub/src/activities/deletion/delete.rs
@@ -119,9 +119,9 @@ pub(in crate::activities) async fn receive_remove_action(
         reason,
         expires: None,
       };
-      ModRemoveCommunity::create(context.pool(), &form).await?;
+      ModRemoveCommunity::create(&mut context.pool(), &form).await?;
       Community::update(
-        context.pool(),
+        &mut context.pool(),
         community.id,
         &CommunityUpdateForm::builder().removed(Some(true)).build(),
       )
@@ -134,9 +134,9 @@ pub(in crate::activities) async fn receive_remove_action(
         removed: Some(true),
         reason,
       };
-      ModRemovePost::create(context.pool(), &form).await?;
+      ModRemovePost::create(&mut context.pool(), &form).await?;
       Post::update(
-        context.pool(),
+        &mut context.pool(),
         post.id,
         &PostUpdateForm::builder().removed(Some(true)).build(),
       )
@@ -149,9 +149,9 @@ pub(in crate::activities) async fn receive_remove_action(
         removed: Some(true),
         reason,
       };
-      ModRemoveComment::create(context.pool(), &form).await?;
+      ModRemoveComment::create(&mut context.pool(), &form).await?;
       Comment::update(
-        context.pool(),
+        &mut context.pool(),
         comment.id,
         &CommentUpdateForm::builder().removed(Some(true)).build(),
       )
diff --git a/crates/apub/src/activities/deletion/delete_user.rs b/crates/apub/src/activities/deletion/delete_user.rs
index 11be132e8..d74a3c8aa 100644
--- a/crates/apub/src/activities/deletion/delete_user.rs
+++ b/crates/apub/src/activities/deletion/delete_user.rs
@@ -32,7 +32,7 @@ impl SendActivity for DeleteAccount {
     let actor: ApubPerson = local_user_view.person.into();
     delete_user_account(
       actor.id,
-      context.pool(),
+      &mut context.pool(),
       context.settings(),
       context.client(),
     )
@@ -51,7 +51,7 @@ impl SendActivity for DeleteAccount {
       cc: vec![],
     };
 
-    let inboxes = remote_instance_inboxes(context.pool()).await?;
+    let inboxes = remote_instance_inboxes(&mut context.pool()).await?;
     send_lemmy_activity(context, delete, &actor, inboxes, true).await?;
     Ok(())
   }
@@ -84,7 +84,7 @@ impl ActivityHandler for DeleteUser {
     let actor = self.actor.dereference(context).await?;
     delete_user_account(
       actor.id,
-      context.pool(),
+      &mut context.pool(),
       context.settings(),
       context.client(),
     )
diff --git a/crates/apub/src/activities/deletion/mod.rs b/crates/apub/src/activities/deletion/mod.rs
index 3bde90f93..3b8c8b537 100644
--- a/crates/apub/src/activities/deletion/mod.rs
+++ b/crates/apub/src/activities/deletion/mod.rs
@@ -64,7 +64,7 @@ impl SendActivity for DeletePost {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), response.post_view.community.id).await?;
+    let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
     let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
     send_apub_delete_in_community(
       local_user_view.person,
@@ -88,7 +88,7 @@ impl SendActivity for RemovePost {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), response.post_view.community.id).await?;
+    let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
     let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
     send_apub_delete_in_community(
       local_user_view.person,
@@ -112,8 +112,8 @@ impl SendActivity for DeleteComment {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let community_id = response.comment_view.community.id;
-    let community = Community::read(context.pool(), community_id).await?;
-    let person = Person::read(context.pool(), response.comment_view.creator.id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
+    let person = Person::read(&mut context.pool(), response.comment_view.creator.id).await?;
     let deletable = DeletableObjects::Comment(response.comment_view.comment.clone().into());
     send_apub_delete_in_community(person, community, deletable, None, request.deleted, context)
       .await
@@ -130,8 +130,9 @@ impl SendActivity for RemoveComment {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let comment = Comment::read(context.pool(), request.comment_id).await?;
-    let community = Community::read(context.pool(), response.comment_view.community.id).await?;
+    let comment = Comment::read(&mut context.pool(), request.comment_id).await?;
+    let community =
+      Community::read(&mut context.pool(), response.comment_view.community.id).await?;
     let deletable = DeletableObjects::Comment(comment.into());
     send_apub_delete_in_community(
       local_user_view.person,
@@ -175,7 +176,7 @@ impl SendActivity for DeleteCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), request.community_id).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
     let deletable = DeletableObjects::Community(community.clone().into());
     send_apub_delete_in_community(
       local_user_view.person,
@@ -199,7 +200,7 @@ impl SendActivity for RemoveCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), request.community_id).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
     let deletable = DeletableObjects::Community(community.clone().into());
     send_apub_delete_in_community(
       local_user_view.person,
@@ -252,7 +253,9 @@ async fn send_apub_delete_private_message(
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
   let recipient_id = pm.recipient_id;
-  let recipient: ApubPerson = Person::read(context.pool(), recipient_id).await?.into();
+  let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
+    .await?
+    .into();
 
   let deletable = DeletableObjects::PrivateMessage(pm.into());
   let inbox = vec![recipient.shared_inbox_or_inbox()];
@@ -388,7 +391,7 @@ async fn receive_delete_action(
       }
 
       Community::update(
-        context.pool(),
+        &mut context.pool(),
         community.id,
         &CommunityUpdateForm::builder()
           .deleted(Some(deleted))
@@ -399,7 +402,7 @@ async fn receive_delete_action(
     DeletableObjects::Post(post) => {
       if deleted != post.deleted {
         Post::update(
-          context.pool(),
+          &mut context.pool(),
           post.id,
           &PostUpdateForm::builder().deleted(Some(deleted)).build(),
         )
@@ -409,7 +412,7 @@ async fn receive_delete_action(
     DeletableObjects::Comment(comment) => {
       if deleted != comment.deleted {
         Comment::update(
-          context.pool(),
+          &mut context.pool(),
           comment.id,
           &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
         )
@@ -418,7 +421,7 @@ async fn receive_delete_action(
     }
     DeletableObjects::PrivateMessage(pm) => {
       PrivateMessage::update(
-        context.pool(),
+        &mut context.pool(),
         pm.id,
         &PrivateMessageUpdateForm::builder()
           .deleted(Some(deleted))
diff --git a/crates/apub/src/activities/deletion/undo_delete.rs b/crates/apub/src/activities/deletion/undo_delete.rs
index 00768580d..639210dd5 100644
--- a/crates/apub/src/activities/deletion/undo_delete.rs
+++ b/crates/apub/src/activities/deletion/undo_delete.rs
@@ -111,9 +111,9 @@ impl UndoDelete {
           reason: None,
           expires: None,
         };
-        ModRemoveCommunity::create(context.pool(), &form).await?;
+        ModRemoveCommunity::create(&mut context.pool(), &form).await?;
         Community::update(
-          context.pool(),
+          &mut context.pool(),
           community.id,
           &CommunityUpdateForm::builder().removed(Some(false)).build(),
         )
@@ -126,9 +126,9 @@ impl UndoDelete {
           removed: Some(false),
           reason: None,
         };
-        ModRemovePost::create(context.pool(), &form).await?;
+        ModRemovePost::create(&mut context.pool(), &form).await?;
         Post::update(
-          context.pool(),
+          &mut context.pool(),
           post.id,
           &PostUpdateForm::builder().removed(Some(false)).build(),
         )
@@ -141,9 +141,9 @@ impl UndoDelete {
           removed: Some(false),
           reason: None,
         };
-        ModRemoveComment::create(context.pool(), &form).await?;
+        ModRemoveComment::create(&mut context.pool(), &form).await?;
         Comment::update(
-          context.pool(),
+          &mut context.pool(),
           comment.id,
           &CommentUpdateForm::builder().removed(Some(false)).build(),
         )
diff --git a/crates/apub/src/activities/following/accept.rs b/crates/apub/src/activities/following/accept.rs
index 7b9ab6802..af7d63725 100644
--- a/crates/apub/src/activities/following/accept.rs
+++ b/crates/apub/src/activities/following/accept.rs
@@ -66,7 +66,7 @@ impl ActivityHandler for AcceptFollow {
     // This will throw an error if no follow was requested
     let community_id = community.id;
     let person_id = person.id;
-    CommunityFollower::follow_accepted(context.pool(), community_id, person_id).await?;
+    CommunityFollower::follow_accepted(&mut context.pool(), community_id, person_id).await?;
 
     Ok(())
   }
diff --git a/crates/apub/src/activities/following/follow.rs b/crates/apub/src/activities/following/follow.rs
index 8a785da05..073784da1 100644
--- a/crates/apub/src/activities/following/follow.rs
+++ b/crates/apub/src/activities/following/follow.rs
@@ -65,7 +65,7 @@ impl Follow {
       person_id: actor.id,
       pending: true,
     };
-    CommunityFollower::follow(context.pool(), &community_follower_form)
+    CommunityFollower::follow(&mut context.pool(), &community_follower_form)
       .await
       .ok();
 
@@ -113,7 +113,7 @@ impl ActivityHandler for Follow {
           follower_id: actor.id,
           pending: false,
         };
-        PersonFollower::follow(context.pool(), &form).await?;
+        PersonFollower::follow(&mut context.pool(), &form).await?;
       }
       UserOrCommunity::Community(c) => {
         let form = CommunityFollowerForm {
@@ -121,7 +121,7 @@ impl ActivityHandler for Follow {
           person_id: actor.id,
           pending: false,
         };
-        CommunityFollower::follow(context.pool(), &form).await?;
+        CommunityFollower::follow(&mut context.pool(), &form).await?;
       }
     }
 
@@ -139,7 +139,7 @@ impl SendActivity for BlockCommunity {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
-    let community = Community::read(context.pool(), request.community_id).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
     UndoFollow::send(&local_user_view.person.into(), &community.into(), context).await
   }
 }
diff --git a/crates/apub/src/activities/following/mod.rs b/crates/apub/src/activities/following/mod.rs
index a4c2fd673..06f95e3f4 100644
--- a/crates/apub/src/activities/following/mod.rs
+++ b/crates/apub/src/activities/following/mod.rs
@@ -27,7 +27,7 @@ impl SendActivity for FollowCommunity {
   ) -> Result<(), LemmyError> {
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
     let person = local_user_view.person.clone().into();
-    let community: ApubCommunity = Community::read(context.pool(), request.community_id)
+    let community: ApubCommunity = Community::read(&mut context.pool(), request.community_id)
       .await?
       .into();
     if community.local {
diff --git a/crates/apub/src/activities/following/undo_follow.rs b/crates/apub/src/activities/following/undo_follow.rs
index 279054d53..9f18ccfbc 100644
--- a/crates/apub/src/activities/following/undo_follow.rs
+++ b/crates/apub/src/activities/following/undo_follow.rs
@@ -82,7 +82,7 @@ impl ActivityHandler for UndoFollow {
           follower_id: person.id,
           pending: false,
         };
-        PersonFollower::unfollow(context.pool(), &form).await?;
+        PersonFollower::unfollow(&mut context.pool(), &form).await?;
       }
       UserOrCommunity::Community(c) => {
         let form = CommunityFollowerForm {
@@ -90,7 +90,7 @@ impl ActivityHandler for UndoFollow {
           person_id: person.id,
           pending: false,
         };
-        CommunityFollower::unfollow(context.pool(), &form).await?;
+        CommunityFollower::unfollow(&mut context.pool(), &form).await?;
       }
     }
 
diff --git a/crates/apub/src/activities/mod.rs b/crates/apub/src/activities/mod.rs
index 4b50c5c83..919d114ad 100644
--- a/crates/apub/src/activities/mod.rs
+++ b/crates/apub/src/activities/mod.rs
@@ -59,7 +59,7 @@ pub(crate) async fn verify_person_in_community(
   }
   let person_id = person.id;
   let community_id = community.id;
-  let is_banned = CommunityPersonBanView::get(context.pool(), person_id, community_id)
+  let is_banned = CommunityPersonBanView::get(&mut context.pool(), person_id, community_id)
     .await
     .is_ok();
   if is_banned {
@@ -84,7 +84,7 @@ pub(crate) async fn verify_mod_action(
   let mod_ = mod_id.dereference(context).await?;
 
   let is_mod_or_admin =
-    CommunityView::is_mod_or_admin(context.pool(), mod_.id, community_id).await?;
+    CommunityView::is_mod_or_admin(&mut context.pool(), mod_.id, community_id).await?;
   if is_mod_or_admin {
     return Ok(());
   }
diff --git a/crates/apub/src/activities/voting/mod.rs b/crates/apub/src/activities/voting/mod.rs
index 8bae05577..24250c501 100644
--- a/crates/apub/src/activities/voting/mod.rs
+++ b/crates/apub/src/activities/voting/mod.rs
@@ -83,9 +83,11 @@ async fn send_activity(
   jwt: &Sensitive<String>,
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
-  let community = Community::read(context.pool(), community_id).await?.into();
+  let community = Community::read(&mut context.pool(), community_id)
+    .await?
+    .into();
   let local_user_view = local_user_view_from_jwt(jwt, context).await?;
-  let actor = Person::read(context.pool(), local_user_view.person.id)
+  let actor = Person::read(&mut context.pool(), local_user_view.person.id)
     .await?
     .into();
 
@@ -118,8 +120,8 @@ async fn vote_comment(
     score: vote_type.into(),
   };
   let person_id = actor.id;
-  CommentLike::remove(context.pool(), person_id, comment_id).await?;
-  CommentLike::like(context.pool(), &like_form).await?;
+  CommentLike::remove(&mut context.pool(), person_id, comment_id).await?;
+  CommentLike::like(&mut context.pool(), &like_form).await?;
   Ok(())
 }
 
@@ -137,8 +139,8 @@ async fn vote_post(
     score: vote_type.into(),
   };
   let person_id = actor.id;
-  PostLike::remove(context.pool(), person_id, post_id).await?;
-  PostLike::like(context.pool(), &like_form).await?;
+  PostLike::remove(&mut context.pool(), person_id, post_id).await?;
+  PostLike::like(&mut context.pool(), &like_form).await?;
   Ok(())
 }
 
@@ -150,7 +152,7 @@ async fn undo_vote_comment(
 ) -> Result<(), LemmyError> {
   let comment_id = comment.id;
   let person_id = actor.id;
-  CommentLike::remove(context.pool(), person_id, comment_id).await?;
+  CommentLike::remove(&mut context.pool(), person_id, comment_id).await?;
   Ok(())
 }
 
@@ -162,6 +164,6 @@ async fn undo_vote_post(
 ) -> Result<(), LemmyError> {
   let post_id = post.id;
   let person_id = actor.id;
-  PostLike::remove(context.pool(), person_id, post_id).await?;
+  PostLike::remove(&mut context.pool(), person_id, post_id).await?;
   Ok(())
 }
diff --git a/crates/apub/src/activities/voting/vote.rs b/crates/apub/src/activities/voting/vote.rs
index 7f36ed471..4de9a8c17 100644
--- a/crates/apub/src/activities/voting/vote.rs
+++ b/crates/apub/src/activities/voting/vote.rs
@@ -58,7 +58,7 @@ impl ActivityHandler for Vote {
   async fn verify(&self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
     let community = self.community(context).await?;
     verify_person_in_community(&self.actor, &community, context).await?;
-    let enable_downvotes = LocalSite::read(context.pool())
+    let enable_downvotes = LocalSite::read(&mut context.pool())
       .await
       .map(|l| l.enable_downvotes)
       .unwrap_or(true);
diff --git a/crates/apub/src/api/list_comments.rs b/crates/apub/src/api/list_comments.rs
index edb70dbaa..498f89a23 100644
--- a/crates/apub/src/api/list_comments.rs
+++ b/crates/apub/src/api/list_comments.rs
@@ -23,7 +23,7 @@ pub async fn list_comments(
   context: Data<LemmyContext>,
 ) -> Result<Json<GetCommentsResponse>, LemmyError> {
   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
   check_private_instance(&local_user_view, &local_site)?;
 
   let community_id = if let Some(name) = &data.community_name {
@@ -43,7 +43,7 @@ pub async fn list_comments(
 
   // If a parent_id is given, fetch the comment to get the path
   let parent_path = if let Some(parent_id) = parent_id {
-    Some(Comment::read(context.pool(), parent_id).await?.path)
+    Some(Comment::read(&mut context.pool(), parent_id).await?.path)
   } else {
     None
   };
@@ -52,7 +52,7 @@ pub async fn list_comments(
   let post_id = data.post_id;
   let local_user = local_user_view.map(|l| l.local_user);
   let comments = CommentQuery::builder()
-    .pool(context.pool())
+    .pool(&mut context.pool())
     .listing_type(Some(listing_type))
     .sort(sort)
     .max_depth(max_depth)
diff --git a/crates/apub/src/api/list_posts.rs b/crates/apub/src/api/list_posts.rs
index ff7ac1089..20a4281d7 100644
--- a/crates/apub/src/api/list_posts.rs
+++ b/crates/apub/src/api/list_posts.rs
@@ -20,7 +20,7 @@ pub async fn list_posts(
   context: Data<LemmyContext>,
 ) -> Result<Json<GetPostsResponse>, LemmyError> {
   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
 
   check_private_instance(&local_user_view, &local_site)?;
 
@@ -38,12 +38,13 @@ pub async fn list_posts(
 
   let listing_type = listing_type_with_default(data.type_, &local_site, community_id)?;
 
-  let is_mod_or_admin = is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), community_id)
-    .await
-    .is_ok();
+  let is_mod_or_admin =
+    is_mod_or_admin_opt(&mut context.pool(), local_user_view.as_ref(), community_id)
+      .await
+      .is_ok();
 
   let posts = PostQuery::builder()
-    .pool(context.pool())
+    .pool(&mut context.pool())
     .local_user(local_user_view.map(|l| l.local_user).as_ref())
     .listing_type(Some(listing_type))
     .sort(sort)
diff --git a/crates/apub/src/api/read_community.rs b/crates/apub/src/api/read_community.rs
index e524694d3..33f3e794b 100644
--- a/crates/apub/src/api/read_community.rs
+++ b/crates/apub/src/api/read_community.rs
@@ -21,7 +21,7 @@ pub async fn read_community(
   context: Data<LemmyContext>,
 ) -> Result<Json<GetCommunityResponse>, LemmyError> {
   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
 
   if data.name.is_none() && data.id.is_none() {
     return Err(LemmyError::from_message("no_id_given"));
@@ -42,13 +42,16 @@ pub async fn read_community(
     }
   };
 
-  let is_mod_or_admin =
-    is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), Some(community_id))
-      .await
-      .is_ok();
+  let is_mod_or_admin = is_mod_or_admin_opt(
+    &mut context.pool(),
+    local_user_view.as_ref(),
+    Some(community_id),
+  )
+  .await
+  .is_ok();
 
   let community_view = CommunityView::read(
-    context.pool(),
+    &mut context.pool(),
     community_id,
     person_id,
     Some(is_mod_or_admin),
@@ -56,12 +59,12 @@ pub async fn read_community(
   .await
   .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
 
-  let moderators = CommunityModeratorView::for_community(context.pool(), community_id)
+  let moderators = CommunityModeratorView::for_community(&mut context.pool(), community_id)
     .await
     .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
 
   let site_id = Site::instance_actor_id_from_url(community_view.community.actor_id.clone().into());
-  let mut site = Site::read_from_apub_id(context.pool(), &site_id.into()).await?;
+  let mut site = Site::read_from_apub_id(&mut context.pool(), &site_id.into()).await?;
   // no need to include metadata for local site (its already available through other endpoints).
   // this also prevents us from leaking the federation private key.
   if let Some(s) = &site {
@@ -71,7 +74,7 @@ pub async fn read_community(
   }
 
   let community_id = community_view.community.id;
-  let discussion_languages = CommunityLanguage::read(context.pool(), community_id).await?;
+  let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
 
   Ok(Json(GetCommunityResponse {
     community_view,
diff --git a/crates/apub/src/api/read_person.rs b/crates/apub/src/api/read_person.rs
index fb4755e38..8fbf5cbd3 100644
--- a/crates/apub/src/api/read_person.rs
+++ b/crates/apub/src/api/read_person.rs
@@ -25,7 +25,7 @@ pub async fn read_person(
   }
 
   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
   let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
 
   check_private_instance(&local_user_view, &local_site)?;
@@ -48,7 +48,7 @@ pub async fn read_person(
 
   // You don't need to return settings for the user, since this comes back with GetSite
   // `my_user`
-  let person_view = PersonView::read(context.pool(), person_details_id).await?;
+  let person_view = PersonView::read(&mut context.pool(), person_details_id).await?;
 
   let sort = data.sort;
   let page = data.page;
@@ -59,7 +59,7 @@ pub async fn read_person(
   let local_user_clone = local_user.clone();
 
   let posts_query = PostQuery::builder()
-    .pool(context.pool())
+    .pool(&mut context.pool())
     .sort(sort)
     .saved_only(saved_only)
     .local_user(local_user.as_ref())
@@ -81,7 +81,7 @@ pub async fn read_person(
   .await?;
 
   let comments_query = CommentQuery::builder()
-    .pool(context.pool())
+    .pool(&mut context.pool())
     .local_user(local_user_clone.as_ref())
     .sort(sort.map(post_to_comment_sort_type))
     .saved_only(saved_only)
@@ -102,7 +102,8 @@ pub async fn read_person(
   }
   .await?;
 
-  let moderates = CommunityModeratorView::for_person(context.pool(), person_details_id).await?;
+  let moderates =
+    CommunityModeratorView::for_person(&mut context.pool(), person_details_id).await?;
 
   // Return the jwt
   Ok(Json(GetPersonDetailsResponse {
diff --git a/crates/apub/src/api/resolve_object.rs b/crates/apub/src/api/resolve_object.rs
index 09689def1..02c0124d9 100644
--- a/crates/apub/src/api/resolve_object.rs
+++ b/crates/apub/src/api/resolve_object.rs
@@ -18,14 +18,14 @@ pub async fn resolve_object(
   context: Data<LemmyContext>,
 ) -> Result<Json<ResolveObjectResponse>, LemmyError> {
   let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
   let person_id = local_user_view.person.id;
   check_private_instance(&Some(local_user_view), &local_site)?;
 
   let res = search_query_to_object_id(&data.q, &context)
     .await
     .map_err(|e| e.with_message("couldnt_find_object"))?;
-  convert_response(res, person_id, context.pool())
+  convert_response(res, person_id, &mut context.pool())
     .await
     .map_err(|e| e.with_message("couldnt_find_object"))
 }
@@ -33,7 +33,7 @@ pub async fn resolve_object(
 async fn convert_response(
   object: SearchableObjects,
   user_id: PersonId,
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<Json<ResolveObjectResponse>, LemmyError> {
   use SearchableObjects::*;
   let removed_or_deleted;
diff --git a/crates/apub/src/api/search.rs b/crates/apub/src/api/search.rs
index 0f9a6b37f..b7723a6f4 100644
--- a/crates/apub/src/api/search.rs
+++ b/crates/apub/src/api/search.rs
@@ -21,7 +21,7 @@ pub async fn search(
   context: Data<LemmyContext>,
 ) -> Result<Json<SearchResponse>, LemmyError> {
   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
-  let local_site = LocalSite::read(context.pool()).await?;
+  let local_site = LocalSite::read(&mut context.pool()).await?;
 
   check_private_instance(&local_user_view, &local_site)?;
 
@@ -54,7 +54,7 @@ pub async fn search(
   match search_type {
     SearchType::Posts => {
       posts = PostQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort)
         .listing_type(listing_type)
         .community_id(community_id)
@@ -70,7 +70,7 @@ pub async fn search(
     }
     SearchType::Comments => {
       comments = CommentQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort.map(post_to_comment_sort_type))
         .listing_type(listing_type)
         .search_term(Some(q))
@@ -85,7 +85,7 @@ pub async fn search(
     }
     SearchType::Communities => {
       communities = CommunityQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort)
         .listing_type(listing_type)
         .search_term(Some(q))
@@ -99,7 +99,7 @@ pub async fn search(
     }
     SearchType::Users => {
       users = PersonQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort)
         .search_term(Some(q))
         .page(page)
@@ -115,7 +115,7 @@ pub async fn search(
 
       let local_user_ = local_user.clone();
       posts = PostQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort)
         .listing_type(listing_type)
         .community_id(community_id)
@@ -133,7 +133,7 @@ pub async fn search(
 
       let local_user_ = local_user.clone();
       comments = CommentQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort.map(post_to_comment_sort_type))
         .listing_type(listing_type)
         .search_term(Some(q))
@@ -152,7 +152,7 @@ pub async fn search(
         vec![]
       } else {
         CommunityQuery::builder()
-          .pool(context.pool())
+          .pool(&mut context.pool())
           .sort(sort)
           .listing_type(listing_type)
           .search_term(Some(q))
@@ -171,7 +171,7 @@ pub async fn search(
         vec![]
       } else {
         PersonQuery::builder()
-          .pool(context.pool())
+          .pool(&mut context.pool())
           .sort(sort)
           .search_term(Some(q))
           .page(page)
@@ -183,7 +183,7 @@ pub async fn search(
     }
     SearchType::Url => {
       posts = PostQuery::builder()
-        .pool(context.pool())
+        .pool(&mut context.pool())
         .sort(sort)
         .listing_type(listing_type)
         .community_id(community_id)
diff --git a/crates/apub/src/collections/community_moderators.rs b/crates/apub/src/collections/community_moderators.rs
index d53f86280..a240e6fb1 100644
--- a/crates/apub/src/collections/community_moderators.rs
+++ b/crates/apub/src/collections/community_moderators.rs
@@ -128,9 +128,10 @@ mod tests {
     let community = parse_lemmy_community(&context).await;
     let community_id = community.id;
 
-    let inserted_instance = Instance::read_or_create(context.pool(), "my_domain.tld".to_string())
-      .await
-      .unwrap();
+    let inserted_instance =
+      Instance::read_or_create(&mut context.pool(), "my_domain.tld".to_string())
+        .await
+        .unwrap();
 
     let old_mod = PersonInsertForm::builder()
       .name("holly".into())
@@ -138,13 +139,13 @@ mod tests {
       .instance_id(inserted_instance.id)
       .build();
 
-    let old_mod = Person::create(context.pool(), &old_mod).await.unwrap();
+    let old_mod = Person::create(&mut context.pool(), &old_mod).await.unwrap();
     let community_moderator_form = CommunityModeratorForm {
       community_id: community.id,
       person_id: old_mod.id,
     };
 
-    CommunityModerator::join(context.pool(), &community_moderator_form)
+    CommunityModerator::join(&mut context.pool(), &community_moderator_form)
       .await
       .unwrap();
 
@@ -161,20 +162,25 @@ mod tests {
       .unwrap();
     assert_eq!(context.request_count(), 0);
 
-    let current_moderators = CommunityModeratorView::for_community(context.pool(), community_id)
-      .await
-      .unwrap();
+    let current_moderators =
+      CommunityModeratorView::for_community(&mut context.pool(), community_id)
+        .await
+        .unwrap();
 
     assert_eq!(current_moderators.len(), 1);
     assert_eq!(current_moderators[0].moderator.id, new_mod.id);
 
-    Person::delete(context.pool(), old_mod.id).await.unwrap();
-    Person::delete(context.pool(), new_mod.id).await.unwrap();
-    Community::delete(context.pool(), community.id)
+    Person::delete(&mut context.pool(), old_mod.id)
       .await
       .unwrap();
-    Site::delete(context.pool(), site.id).await.unwrap();
-    Instance::delete(context.pool(), inserted_instance.id)
+    Person::delete(&mut context.pool(), new_mod.id)
+      .await
+      .unwrap();
+    Community::delete(&mut context.pool(), community.id)
+      .await
+      .unwrap();
+    Site::delete(&mut context.pool(), site.id).await.unwrap();
+    Instance::delete(&mut context.pool(), inserted_instance.id)
       .await
       .unwrap();
   }
diff --git a/crates/apub/src/fetcher/mod.rs b/crates/apub/src/fetcher/mod.rs
index 4f72d1488..701d10383 100644
--- a/crates/apub/src/fetcher/mod.rs
+++ b/crates/apub/src/fetcher/mod.rs
@@ -41,7 +41,7 @@ where
       .splitn(2, '@')
       .collect_tuple()
       .expect("invalid query");
-    let actor = DbActor::read_from_name_and_domain(context.pool(), name, domain).await;
+    let actor = DbActor::read_from_name_and_domain(&mut context.pool(), name, domain).await;
     if actor.is_ok() {
       Ok(actor?.into())
     } else if local_user_view.is_some() {
@@ -56,7 +56,7 @@ where
   else {
     let identifier = identifier.to_string();
     Ok(
-      DbActor::read_from_name(context.pool(), &identifier, include_deleted)
+      DbActor::read_from_name(&mut context.pool(), &identifier, include_deleted)
         .await?
         .into(),
     )
diff --git a/crates/apub/src/fetcher/post_or_comment.rs b/crates/apub/src/fetcher/post_or_comment.rs
index 651abf7db..929149669 100644
--- a/crates/apub/src/fetcher/post_or_comment.rs
+++ b/crates/apub/src/fetcher/post_or_comment.rs
@@ -91,8 +91,12 @@ impl InCommunity for PostOrComment {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let cid = match self {
       PostOrComment::Post(p) => p.community_id,
-      PostOrComment::Comment(c) => Post::read(context.pool(), c.post_id).await?.community_id,
+      PostOrComment::Comment(c) => {
+        Post::read(&mut context.pool(), c.post_id)
+          .await?
+          .community_id
+      }
     };
-    Ok(Community::read(context.pool(), cid).await?.into())
+    Ok(Community::read(&mut context.pool(), cid).await?.into())
   }
 }
diff --git a/crates/apub/src/http/comment.rs b/crates/apub/src/http/comment.rs
index 9e78da2ab..66794f90c 100644
--- a/crates/apub/src/http/comment.rs
+++ b/crates/apub/src/http/comment.rs
@@ -21,7 +21,7 @@ pub(crate) async fn get_apub_comment(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let id = CommentId(info.comment_id.parse::<i32>()?);
-  let comment: ApubComment = Comment::read(context.pool(), id).await?.into();
+  let comment: ApubComment = Comment::read(&mut context.pool(), id).await?.into();
   if !comment.local {
     return Err(err_object_not_local());
   }
diff --git a/crates/apub/src/http/community.rs b/crates/apub/src/http/community.rs
index 04ac8e3fd..54073a107 100644
--- a/crates/apub/src/http/community.rs
+++ b/crates/apub/src/http/community.rs
@@ -33,7 +33,7 @@ pub(crate) async fn get_apub_community_http(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let community: ApubCommunity =
-    Community::read_from_name(context.pool(), &info.community_name, true)
+    Community::read_from_name(&mut context.pool(), &info.community_name, true)
       .await?
       .into();
 
@@ -64,7 +64,8 @@ pub(crate) async fn get_apub_community_followers(
   info: web::Path<CommunityQuery>,
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
-  let community = Community::read_from_name(context.pool(), &info.community_name, false).await?;
+  let community =
+    Community::read_from_name(&mut context.pool(), &info.community_name, false).await?;
   let followers = GroupFollowers::new(community, &context).await?;
   create_apub_response(&followers)
 }
@@ -76,7 +77,7 @@ pub(crate) async fn get_apub_community_outbox(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let community: ApubCommunity =
-    Community::read_from_name(context.pool(), &info.community_name, false)
+    Community::read_from_name(&mut context.pool(), &info.community_name, false)
       .await?
       .into();
   if community.deleted || community.removed {
@@ -92,7 +93,7 @@ pub(crate) async fn get_apub_community_moderators(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let community: ApubCommunity =
-    Community::read_from_name(context.pool(), &info.community_name, false)
+    Community::read_from_name(&mut context.pool(), &info.community_name, false)
       .await?
       .into();
   if community.deleted || community.removed {
@@ -108,7 +109,7 @@ pub(crate) async fn get_apub_community_featured(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let community: ApubCommunity =
-    Community::read_from_name(context.pool(), &info.community_name, false)
+    Community::read_from_name(&mut context.pool(), &info.community_name, false)
       .await?
       .into();
   if community.deleted || community.removed {
diff --git a/crates/apub/src/http/mod.rs b/crates/apub/src/http/mod.rs
index 66d5a0f9f..88cff25c7 100644
--- a/crates/apub/src/http/mod.rs
+++ b/crates/apub/src/http/mod.rs
@@ -88,7 +88,7 @@ pub(crate) async fn get_activity(
     info.id
   ))?
   .into();
-  let activity = Activity::read_from_apub_id(context.pool(), &activity_id).await?;
+  let activity = Activity::read_from_apub_id(&mut context.pool(), &activity_id).await?;
 
   let sensitive = activity.sensitive;
   if !activity.local {
diff --git a/crates/apub/src/http/person.rs b/crates/apub/src/http/person.rs
index 453905eee..16956ec47 100644
--- a/crates/apub/src/http/person.rs
+++ b/crates/apub/src/http/person.rs
@@ -30,7 +30,7 @@ pub(crate) async fn get_apub_person_http(
 ) -> Result<HttpResponse, LemmyError> {
   let user_name = info.into_inner().user_name;
   // TODO: this needs to be able to read deleted persons, so that it can send tombstones
-  let person: ApubPerson = Person::read_from_name(context.pool(), &user_name, true)
+  let person: ApubPerson = Person::read_from_name(&mut context.pool(), &user_name, true)
     .await?
     .into();
 
@@ -60,7 +60,7 @@ pub(crate) async fn get_apub_person_outbox(
   info: web::Path<PersonQuery>,
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
-  let person = Person::read_from_name(context.pool(), &info.user_name, false).await?;
+  let person = Person::read_from_name(&mut context.pool(), &info.user_name, false).await?;
   let outbox_id = generate_outbox_url(&person.actor_id)?.into();
   let outbox = EmptyOutbox::new(outbox_id)?;
   create_apub_response(&outbox)
diff --git a/crates/apub/src/http/post.rs b/crates/apub/src/http/post.rs
index a2e600268..4da3dc14f 100644
--- a/crates/apub/src/http/post.rs
+++ b/crates/apub/src/http/post.rs
@@ -21,7 +21,7 @@ pub(crate) async fn get_apub_post(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
   let id = PostId(info.post_id.parse::<i32>()?);
-  let post: ApubPost = Post::read(context.pool(), id).await?.into();
+  let post: ApubPost = Post::read(&mut context.pool(), id).await?.into();
   if !post.local {
     return Err(err_object_not_local());
   }
diff --git a/crates/apub/src/http/site.rs b/crates/apub/src/http/site.rs
index 676ce9bd6..071f4aa6e 100644
--- a/crates/apub/src/http/site.rs
+++ b/crates/apub/src/http/site.rs
@@ -19,7 +19,7 @@ use url::Url;
 pub(crate) async fn get_apub_site_http(
   context: Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
-  let site: ApubSite = SiteView::read_local(context.pool()).await?.site.into();
+  let site: ApubSite = SiteView::read_local(&mut context.pool()).await?.site.into();
 
   let apub = site.into_json(&context).await?;
   create_apub_response(&apub)
diff --git a/crates/apub/src/lib.rs b/crates/apub/src/lib.rs
index a5bc41d1f..4ba38c316 100644
--- a/crates/apub/src/lib.rs
+++ b/crates/apub/src/lib.rs
@@ -10,6 +10,7 @@ use lemmy_db_schema::{
   },
   traits::Crud,
   utils::DbPool,
+  DbPoolRef,
 };
 use lemmy_utils::{error::LemmyError, settings::structs::Settings};
 use once_cell::sync::Lazy;
@@ -98,7 +99,7 @@ pub(crate) struct LocalSiteData {
 }
 
 pub(crate) async fn fetch_local_site_data(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
 ) -> Result<LocalSiteData, diesel::result::Error> {
   // LocalSite may be missing
   let local_site = LocalSite::read(pool).await.ok();
diff --git a/crates/apub/src/mentions.rs b/crates/apub/src/mentions.rs
index 088f84d0d..cdbe504a3 100644
--- a/crates/apub/src/mentions.rs
+++ b/crates/apub/src/mentions.rs
@@ -10,6 +10,7 @@ use lemmy_db_schema::{
   source::{comment::Comment, person::Person, post::Post},
   traits::Crud,
   utils::DbPool,
+  DbPoolRef,
 };
 use lemmy_utils::{error::LemmyError, utils::mention::scrape_text_for_mentions};
 use serde::{Deserialize, Serialize};
@@ -45,7 +46,7 @@ pub async fn collect_non_local_mentions(
   community_id: ObjectId<ApubCommunity>,
   context: &Data<LemmyContext>,
 ) -> Result<MentionsAndAddresses, LemmyError> {
-  let parent_creator = get_comment_parent_creator(context.pool(), comment).await?;
+  let parent_creator = get_comment_parent_creator(&mut context.pool(), comment).await?;
   let mut addressed_ccs: Vec<Url> = vec![community_id.into(), parent_creator.id()];
 
   // Add the mention tag
@@ -92,7 +93,7 @@ pub async fn collect_non_local_mentions(
 /// top-level comment, the creator of the post, otherwise the creator of the parent comment.
 #[tracing::instrument(skip(pool, comment))]
 async fn get_comment_parent_creator(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   comment: &Comment,
 ) -> Result<ApubPerson, LemmyError> {
   let parent_creator_id = if let Some(parent_comment_id) = comment.parent_comment_id() {
diff --git a/crates/apub/src/objects/comment.rs b/crates/apub/src/objects/comment.rs
index 16cb1542b..66dc13f5b 100644
--- a/crates/apub/src/objects/comment.rs
+++ b/crates/apub/src/objects/comment.rs
@@ -67,7 +67,7 @@ impl Object for ApubComment {
     context: &Data<Self::DataType>,
   ) -> Result<Option<Self>, LemmyError> {
     Ok(
-      Comment::read_from_apub_id(context.pool(), object_id)
+      Comment::read_from_apub_id(&mut context.pool(), object_id)
         .await?
         .map(Into::into),
     )
@@ -77,7 +77,7 @@ impl Object for ApubComment {
   async fn delete(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     if !self.deleted {
       let form = CommentUpdateForm::builder().deleted(Some(true)).build();
-      Comment::update(context.pool(), self.id, &form).await?;
+      Comment::update(&mut context.pool(), self.id, &form).await?;
     }
     Ok(())
   }
@@ -85,20 +85,20 @@ impl Object for ApubComment {
   #[tracing::instrument(skip_all)]
   async fn into_json(self, context: &Data<Self::DataType>) -> Result<Note, LemmyError> {
     let creator_id = self.creator_id;
-    let creator = Person::read(context.pool(), creator_id).await?;
+    let creator = Person::read(&mut context.pool(), creator_id).await?;
 
     let post_id = self.post_id;
-    let post = Post::read(context.pool(), post_id).await?;
+    let post = Post::read(&mut context.pool(), post_id).await?;
     let community_id = post.community_id;
-    let community = Community::read(context.pool(), community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
 
     let in_reply_to = if let Some(comment_id) = self.parent_comment_id() {
-      let parent_comment = Comment::read(context.pool(), comment_id).await?;
+      let parent_comment = Comment::read(&mut context.pool(), comment_id).await?;
       parent_comment.ap_id.into()
     } else {
       post.ap_id.into()
     };
-    let language = LanguageTag::new_single(self.language_id, context.pool()).await?;
+    let language = LanguageTag::new_single(self.language_id, &mut context.pool()).await?;
     let maa = collect_non_local_mentions(&self, community.actor_id.clone().into(), context).await?;
 
     let note = Note {
@@ -132,7 +132,7 @@ impl Object for ApubComment {
     verify_domains_match(note.attributed_to.inner(), note.id.inner())?;
     verify_is_public(&note.to, &note.cc)?;
     let community = note.community(context).await?;
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
 
     check_apub_id_valid_with_strictness(
       note.id.inner(),
@@ -159,10 +159,11 @@ impl Object for ApubComment {
 
     let content = read_from_string_or_source(&note.content, &note.media_type, &note.source);
 
-    let local_site = LocalSite::read(context.pool()).await.ok();
+    let local_site = LocalSite::read(&mut context.pool()).await.ok();
     let slur_regex = &local_site_opt_to_slur_regex(&local_site);
     let content_slurs_removed = remove_slurs(&content, slur_regex);
-    let language_id = LanguageTag::to_language_id_single(note.language, context.pool()).await?;
+    let language_id =
+      LanguageTag::to_language_id_single(note.language, &mut context.pool()).await?;
 
     let form = CommentInsertForm {
       creator_id: creator.id,
@@ -178,7 +179,7 @@ impl Object for ApubComment {
       language_id,
     };
     let parent_comment_path = parent_comment.map(|t| t.0.path);
-    let comment = Comment::create(context.pool(), &form, parent_comment_path.as_ref()).await?;
+    let comment = Comment::create(&mut context.pool(), &form, parent_comment_path.as_ref()).await?;
     Ok(comment.into())
   }
 }
@@ -216,11 +217,15 @@ pub(crate) mod tests {
   }
 
   async fn cleanup(data: (ApubPerson, ApubCommunity, ApubPost, ApubSite), context: &LemmyContext) {
-    Post::delete(context.pool(), data.2.id).await.unwrap();
-    Community::delete(context.pool(), data.1.id).await.unwrap();
-    Person::delete(context.pool(), data.0.id).await.unwrap();
-    Site::delete(context.pool(), data.3.id).await.unwrap();
-    LocalSite::delete(context.pool()).await.unwrap();
+    Post::delete(&mut context.pool(), data.2.id).await.unwrap();
+    Community::delete(&mut context.pool(), data.1.id)
+      .await
+      .unwrap();
+    Person::delete(&mut context.pool(), data.0.id)
+      .await
+      .unwrap();
+    Site::delete(&mut context.pool(), data.3.id).await.unwrap();
+    LocalSite::delete(&mut context.pool()).await.unwrap();
   }
 
   #[tokio::test]
@@ -245,7 +250,9 @@ pub(crate) mod tests {
     let to_apub = comment.into_json(&context).await.unwrap();
     assert_json_include!(actual: json, expected: to_apub);
 
-    Comment::delete(context.pool(), comment_id).await.unwrap();
+    Comment::delete(&mut context.pool(), comment_id)
+      .await
+      .unwrap();
     cleanup(data, &context).await;
   }
 
@@ -275,7 +282,9 @@ pub(crate) mod tests {
     assert!(!comment.local);
     assert_eq!(context.request_count(), 1);
 
-    Comment::delete(context.pool(), comment.id).await.unwrap();
+    Comment::delete(&mut context.pool(), comment.id)
+      .await
+      .unwrap();
     cleanup(data, &context).await;
   }
 
diff --git a/crates/apub/src/objects/community.rs b/crates/apub/src/objects/community.rs
index 17476e9f8..a12036481 100644
--- a/crates/apub/src/objects/community.rs
+++ b/crates/apub/src/objects/community.rs
@@ -67,7 +67,7 @@ impl Object for ApubCommunity {
     context: &Data<Self::DataType>,
   ) -> Result<Option<Self>, LemmyError> {
     Ok(
-      Community::read_from_apub_id(context.pool(), &object_id.into())
+      Community::read_from_apub_id(&mut context.pool(), &object_id.into())
         .await?
         .map(Into::into),
     )
@@ -76,7 +76,7 @@ impl Object for ApubCommunity {
   #[tracing::instrument(skip_all)]
   async fn delete(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     let form = CommunityUpdateForm::builder().deleted(Some(true)).build();
-    Community::update(context.pool(), self.id, &form).await?;
+    Community::update(&mut context.pool(), self.id, &form).await?;
     Ok(())
   }
 
@@ -131,10 +131,11 @@ impl Object for ApubCommunity {
     let instance_id = fetch_instance_actor_for_object(&group.id, context).await?;
 
     let form = Group::into_insert_form(group.clone(), instance_id);
-    let languages = LanguageTag::to_language_id_multiple(group.language, context.pool()).await?;
+    let languages =
+      LanguageTag::to_language_id_multiple(group.language, &mut context.pool()).await?;
 
-    let community = Community::create(context.pool(), &form).await?;
-    CommunityLanguage::update(context.pool(), languages, community.id).await?;
+    let community = Community::create(&mut context.pool(), &form).await?;
+    CommunityLanguage::update(&mut context.pool(), languages, community.id).await?;
 
     let community: ApubCommunity = community.into();
 
@@ -187,8 +188,8 @@ impl ApubCommunity {
   ) -> Result<Vec<Url>, LemmyError> {
     let id = self.id;
 
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
-    let follows = CommunityFollowerView::for_community(context.pool(), id).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
+    let follows = CommunityFollowerView::for_community(&mut context.pool(), id).await?;
     let inboxes: Vec<Url> = follows
       .into_iter()
       .filter(|f| !f.follower.local)
@@ -250,9 +251,9 @@ pub(crate) mod tests {
     assert!(!community.local);
     assert_eq!(community.description.as_ref().unwrap().len(), 132);
 
-    Community::delete(context.pool(), community.id)
+    Community::delete(&mut context.pool(), community.id)
       .await
       .unwrap();
-    Site::delete(context.pool(), site.id).await.unwrap();
+    Site::delete(&mut context.pool(), site.id).await.unwrap();
   }
 }
diff --git a/crates/apub/src/objects/instance.rs b/crates/apub/src/objects/instance.rs
index 6cd27fbbd..cdf6b60ea 100644
--- a/crates/apub/src/objects/instance.rs
+++ b/crates/apub/src/objects/instance.rs
@@ -25,7 +25,7 @@ use lemmy_db_schema::{
     site::{Site, SiteInsertForm},
   },
   traits::Crud,
-  utils::{naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef},
 };
 use lemmy_utils::{
   error::LemmyError,
@@ -187,7 +187,7 @@ pub(in crate::objects) async fn fetch_instance_actor_for_object<T: Into<Url> + C
       debug!("Failed to dereference site for {}: {}", &instance_id, e);
       let domain = instance_id.domain().expect("has domain");
       Ok(
-        DbInstance::read_or_create(context.pool(), domain.to_string())
+        DbInstance::read_or_create(&mut context.pool(), domain.to_string())
           .await?
           .id,
       )
@@ -195,7 +195,7 @@ pub(in crate::objects) async fn fetch_instance_actor_for_object<T: Into<Url> + C
   }
 }
 
-pub(crate) async fn remote_instance_inboxes(pool: &DbPool) -> Result<Vec<Url>, LemmyError> {
+pub(crate) async fn remote_instance_inboxes(pool: DbPoolRef<'_>) -> Result<Vec<Url>, LemmyError> {
   Ok(
     Site::read_remote_sites(pool)
       .await?
@@ -230,6 +230,6 @@ pub(crate) mod tests {
     assert_eq!(site.name, "Enterprise");
     assert_eq!(site.description.as_ref().unwrap().len(), 15);
 
-    Site::delete(context.pool(), site.id).await.unwrap();
+    Site::delete(&mut context.pool(), site.id).await.unwrap();
   }
 }
diff --git a/crates/apub/src/objects/person.rs b/crates/apub/src/objects/person.rs
index 3eeb733fd..471c95ea5 100644
--- a/crates/apub/src/objects/person.rs
+++ b/crates/apub/src/objects/person.rs
@@ -69,7 +69,7 @@ impl Object for ApubPerson {
     context: &Data<Self::DataType>,
   ) -> Result<Option<Self>, LemmyError> {
     Ok(
-      DbPerson::read_from_apub_id(context.pool(), &object_id.into())
+      DbPerson::read_from_apub_id(&mut context.pool(), &object_id.into())
         .await?
         .map(Into::into),
     )
@@ -78,7 +78,7 @@ impl Object for ApubPerson {
   #[tracing::instrument(skip_all)]
   async fn delete(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     let form = PersonUpdateForm::builder().deleted(Some(true)).build();
-    DbPerson::update(context.pool(), self.id, &form).await?;
+    DbPerson::update(&mut context.pool(), self.id, &form).await?;
     Ok(())
   }
 
@@ -118,7 +118,7 @@ impl Object for ApubPerson {
     expected_domain: &Url,
     context: &Data<Self::DataType>,
   ) -> Result<(), LemmyError> {
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
     let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
 
     check_slurs(&person.preferred_username, slur_regex)?;
@@ -171,7 +171,7 @@ impl Object for ApubPerson {
       matrix_user_id: person.matrix_user_id,
       instance_id,
     };
-    let person = DbPerson::upsert(context.pool(), &person_form).await?;
+    let person = DbPerson::upsert(&mut context.pool(), &person_form).await?;
 
     Ok(person.into())
   }
@@ -262,7 +262,9 @@ pub(crate) mod tests {
   }
 
   async fn cleanup(data: (ApubPerson, ApubSite), context: &LemmyContext) {
-    DbPerson::delete(context.pool(), data.0.id).await.unwrap();
-    Site::delete(context.pool(), data.1.id).await.unwrap();
+    DbPerson::delete(&mut context.pool(), data.0.id)
+      .await
+      .unwrap();
+    Site::delete(&mut context.pool(), data.1.id).await.unwrap();
   }
 }
diff --git a/crates/apub/src/objects/post.rs b/crates/apub/src/objects/post.rs
index 7878fcf12..598a89367 100644
--- a/crates/apub/src/objects/post.rs
+++ b/crates/apub/src/objects/post.rs
@@ -83,7 +83,7 @@ impl Object for ApubPost {
     context: &Data<Self::DataType>,
   ) -> Result<Option<Self>, LemmyError> {
     Ok(
-      Post::read_from_apub_id(context.pool(), object_id)
+      Post::read_from_apub_id(&mut context.pool(), object_id)
         .await?
         .map(Into::into),
     )
@@ -93,7 +93,7 @@ impl Object for ApubPost {
   async fn delete(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
     if !self.deleted {
       let form = PostUpdateForm::builder().deleted(Some(true)).build();
-      Post::update(context.pool(), self.id, &form).await?;
+      Post::update(&mut context.pool(), self.id, &form).await?;
     }
     Ok(())
   }
@@ -102,10 +102,10 @@ impl Object for ApubPost {
   #[tracing::instrument(skip_all)]
   async fn into_json(self, context: &Data<Self::DataType>) -> Result<Page, LemmyError> {
     let creator_id = self.creator_id;
-    let creator = Person::read(context.pool(), creator_id).await?;
+    let creator = Person::read(&mut context.pool(), creator_id).await?;
     let community_id = self.community_id;
-    let community = Community::read(context.pool(), community_id).await?;
-    let language = LanguageTag::new_single(self.language_id, context.pool()).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
+    let language = LanguageTag::new_single(self.language_id, &mut context.pool()).await?;
 
     let page = Page {
       kind: PageType::Page,
@@ -143,7 +143,7 @@ impl Object for ApubPost {
       verify_is_remote_object(page.id.inner(), context.settings())?;
     };
 
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
 
     let community = page.community(context).await?;
     check_apub_id_valid_with_strictness(
@@ -167,7 +167,7 @@ impl Object for ApubPost {
     let creator = page.creator()?.dereference(context).await?;
     let community = page.community(context).await?;
     if community.posting_restricted_to_mods {
-      is_mod_or_admin(context.pool(), creator.id, community.id).await?;
+      is_mod_or_admin(&mut context.pool(), creator.id, community.id).await?;
     }
     let mut name = page
       .name
@@ -198,7 +198,7 @@ impl Object for ApubPost {
         None
       };
 
-      let local_site = LocalSite::read(context.pool()).await.ok();
+      let local_site = LocalSite::read(&mut context.pool()).await.ok();
       let allow_sensitive = local_site_opt_to_sensitive(&local_site);
       let page_is_sensitive = page.sensitive.unwrap_or(false);
       let include_image = allow_sensitive || !page_is_sensitive;
@@ -229,7 +229,8 @@ impl Object for ApubPost {
       let body_slurs_removed =
         read_from_string_or_source_opt(&page.content, &page.media_type, &page.source)
           .map(|s| remove_slurs(&s, slur_regex));
-      let language_id = LanguageTag::to_language_id_single(page.language, context.pool()).await?;
+      let language_id =
+        LanguageTag::to_language_id_single(page.language, &mut context.pool()).await?;
 
       PostInsertForm {
         name,
@@ -265,7 +266,7 @@ impl Object for ApubPost {
         .build()
     };
 
-    let post = Post::create(context.pool(), &form).await?;
+    let post = Post::create(&mut context.pool(), &form).await?;
 
     // write mod log entry for lock
     if Page::is_locked_changed(&old_post, &page.comments_enabled) {
@@ -274,7 +275,7 @@ impl Object for ApubPost {
         post_id: post.id,
         locked: Some(post.locked),
       };
-      ModLockPost::create(context.pool(), &form).await?;
+      ModLockPost::create(&mut context.pool(), &form).await?;
     }
 
     Ok(post.into())
@@ -316,11 +317,13 @@ mod tests {
     assert!(!post.featured_community);
     assert_eq!(context.request_count(), 0);
 
-    Post::delete(context.pool(), post.id).await.unwrap();
-    Person::delete(context.pool(), person.id).await.unwrap();
-    Community::delete(context.pool(), community.id)
+    Post::delete(&mut context.pool(), post.id).await.unwrap();
+    Person::delete(&mut context.pool(), person.id)
       .await
       .unwrap();
-    Site::delete(context.pool(), site.id).await.unwrap();
+    Community::delete(&mut context.pool(), community.id)
+      .await
+      .unwrap();
+    Site::delete(&mut context.pool(), site.id).await.unwrap();
   }
 }
diff --git a/crates/apub/src/objects/private_message.rs b/crates/apub/src/objects/private_message.rs
index ae2637c58..2c77ac8da 100644
--- a/crates/apub/src/objects/private_message.rs
+++ b/crates/apub/src/objects/private_message.rs
@@ -60,7 +60,7 @@ impl Object for ApubPrivateMessage {
     context: &Data<Self::DataType>,
   ) -> Result<Option<Self>, LemmyError> {
     Ok(
-      PrivateMessage::read_from_apub_id(context.pool(), object_id)
+      PrivateMessage::read_from_apub_id(&mut context.pool(), object_id)
         .await?
         .map(Into::into),
     )
@@ -74,10 +74,10 @@ impl Object for ApubPrivateMessage {
   #[tracing::instrument(skip_all)]
   async fn into_json(self, context: &Data<Self::DataType>) -> Result<ChatMessage, LemmyError> {
     let creator_id = self.creator_id;
-    let creator = Person::read(context.pool(), creator_id).await?;
+    let creator = Person::read(&mut context.pool(), creator_id).await?;
 
     let recipient_id = self.recipient_id;
-    let recipient = Person::read(context.pool(), recipient_id).await?;
+    let recipient = Person::read(&mut context.pool(), recipient_id).await?;
 
     let note = ChatMessage {
       r#type: ChatMessageType::ChatMessage,
@@ -102,7 +102,7 @@ impl Object for ApubPrivateMessage {
     verify_domains_match(note.id.inner(), expected_domain)?;
     verify_domains_match(note.attributed_to.inner(), note.id.inner())?;
 
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
 
     check_apub_id_valid_with_strictness(
       note.id.inner(),
@@ -124,7 +124,7 @@ impl Object for ApubPrivateMessage {
   ) -> Result<ApubPrivateMessage, LemmyError> {
     let creator = note.attributed_to.dereference(context).await?;
     let recipient = note.to[0].dereference(context).await?;
-    check_person_block(creator.id, recipient.id, context.pool()).await?;
+    check_person_block(creator.id, recipient.id, &mut context.pool()).await?;
 
     let form = PrivateMessageInsertForm {
       creator_id: creator.id,
@@ -137,7 +137,7 @@ impl Object for ApubPrivateMessage {
       ap_id: Some(note.id.into()),
       local: Some(false),
     };
-    let pm = PrivateMessage::create(context.pool(), &form).await?;
+    let pm = PrivateMessage::create(&mut context.pool(), &form).await?;
     Ok(pm.into())
   }
 }
@@ -182,9 +182,13 @@ mod tests {
   }
 
   async fn cleanup(data: (ApubPerson, ApubPerson, ApubSite), context: &Data<LemmyContext>) {
-    Person::delete(context.pool(), data.0.id).await.unwrap();
-    Person::delete(context.pool(), data.1.id).await.unwrap();
-    Site::delete(context.pool(), data.2.id).await.unwrap();
+    Person::delete(&mut context.pool(), data.0.id)
+      .await
+      .unwrap();
+    Person::delete(&mut context.pool(), data.1.id)
+      .await
+      .unwrap();
+    Site::delete(&mut context.pool(), data.2.id).await.unwrap();
   }
 
   #[tokio::test]
@@ -209,7 +213,9 @@ mod tests {
     let to_apub = pm.into_json(&context).await.unwrap();
     assert_json_include!(actual: json, expected: to_apub);
 
-    PrivateMessage::delete(context.pool(), pm_id).await.unwrap();
+    PrivateMessage::delete(&mut context.pool(), pm_id)
+      .await
+      .unwrap();
     cleanup(data, &context).await;
   }
 
@@ -230,7 +236,9 @@ mod tests {
     assert_eq!(pm.content.len(), 3);
     assert_eq!(context.request_count(), 0);
 
-    PrivateMessage::delete(context.pool(), pm.id).await.unwrap();
+    PrivateMessage::delete(&mut context.pool(), pm.id)
+      .await
+      .unwrap();
     cleanup(data, &context).await;
   }
 }
diff --git a/crates/apub/src/protocol/activities/community/collection_add.rs b/crates/apub/src/protocol/activities/community/collection_add.rs
index f3943e31c..edf67740a 100644
--- a/crates/apub/src/protocol/activities/community/collection_add.rs
+++ b/crates/apub/src/protocol/activities/community/collection_add.rs
@@ -35,7 +35,7 @@ pub struct CollectionAdd {
 impl InCommunity for CollectionAdd {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let (community, _) =
-      Community::get_by_collection_url(context.pool(), &self.clone().target.into()).await?;
+      Community::get_by_collection_url(&mut context.pool(), &self.clone().target.into()).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/apub/src/protocol/activities/community/collection_remove.rs b/crates/apub/src/protocol/activities/community/collection_remove.rs
index f69fdc6a7..960951732 100644
--- a/crates/apub/src/protocol/activities/community/collection_remove.rs
+++ b/crates/apub/src/protocol/activities/community/collection_remove.rs
@@ -35,7 +35,7 @@ pub struct CollectionRemove {
 impl InCommunity for CollectionRemove {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let (community, _) =
-      Community::get_by_collection_url(context.pool(), &self.clone().target.into()).await?;
+      Community::get_by_collection_url(&mut context.pool(), &self.clone().target.into()).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/apub/src/protocol/activities/community/lock_page.rs b/crates/apub/src/protocol/activities/community/lock_page.rs
index b19e39749..33b108531 100644
--- a/crates/apub/src/protocol/activities/community/lock_page.rs
+++ b/crates/apub/src/protocol/activities/community/lock_page.rs
@@ -55,7 +55,7 @@ pub struct UndoLockPage {
 impl InCommunity for LockPage {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let post = self.object.dereference(context).await?;
-    let community = Community::read(context.pool(), post.community_id).await?;
+    let community = Community::read(&mut context.pool(), post.community_id).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/apub/src/protocol/activities/create_or_update/note.rs b/crates/apub/src/protocol/activities/create_or_update/note.rs
index 07bbc7c8d..6fabc0aaa 100644
--- a/crates/apub/src/protocol/activities/create_or_update/note.rs
+++ b/crates/apub/src/protocol/activities/create_or_update/note.rs
@@ -36,7 +36,7 @@ pub struct CreateOrUpdateNote {
 impl InCommunity for CreateOrUpdateNote {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let post = self.object.get_parents(context).await?.0;
-    let community = Community::read(context.pool(), post.community_id).await?;
+    let community = Community::read(&mut context.pool(), post.community_id).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/apub/src/protocol/activities/deletion/delete.rs b/crates/apub/src/protocol/activities/deletion/delete.rs
index 89ee26d94..2a7bfeebe 100644
--- a/crates/apub/src/protocol/activities/deletion/delete.rs
+++ b/crates/apub/src/protocol/activities/deletion/delete.rs
@@ -48,7 +48,7 @@ impl InCommunity for Delete {
     let community_id = match DeletableObjects::read_from_db(self.object.id(), context).await? {
       DeletableObjects::Community(c) => c.id,
       DeletableObjects::Comment(c) => {
-        let post = Post::read(context.pool(), c.post_id).await?;
+        let post = Post::read(&mut context.pool(), c.post_id).await?;
         post.community_id
       }
       DeletableObjects::Post(p) => p.community_id,
@@ -56,7 +56,7 @@ impl InCommunity for Delete {
         return Err(anyhow!("Private message is not part of community").into())
       }
     };
-    let community = Community::read(context.pool(), community_id).await?;
+    let community = Community::read(&mut context.pool(), community_id).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/apub/src/protocol/collections/group_followers.rs b/crates/apub/src/protocol/collections/group_followers.rs
index c7df8df2b..108352b81 100644
--- a/crates/apub/src/protocol/collections/group_followers.rs
+++ b/crates/apub/src/protocol/collections/group_followers.rs
@@ -22,7 +22,7 @@ impl GroupFollowers {
   ) -> Result<GroupFollowers, LemmyError> {
     let community_id = community.id;
     let community_followers =
-      CommunityFollowerView::for_community(context.pool(), community_id).await?;
+      CommunityFollowerView::for_community(&mut context.pool(), community_id).await?;
 
     Ok(GroupFollowers {
       id: generate_followers_url(&community.actor_id)?.into(),
diff --git a/crates/apub/src/protocol/objects/group.rs b/crates/apub/src/protocol/objects/group.rs
index 2b32915af..ebdec6b37 100644
--- a/crates/apub/src/protocol/objects/group.rs
+++ b/crates/apub/src/protocol/objects/group.rs
@@ -80,7 +80,7 @@ impl Group {
     expected_domain: &Url,
     context: &LemmyContext,
   ) -> Result<(), LemmyError> {
-    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    let local_site_data = fetch_local_site_data(&mut context.pool()).await?;
 
     check_apub_id_valid_with_strictness(
       self.id.inner(),
diff --git a/crates/apub/src/protocol/objects/mod.rs b/crates/apub/src/protocol/objects/mod.rs
index f35140a9b..2fb87b5e0 100644
--- a/crates/apub/src/protocol/objects/mod.rs
+++ b/crates/apub/src/protocol/objects/mod.rs
@@ -3,6 +3,7 @@ use lemmy_db_schema::{
   newtypes::LanguageId,
   source::language::Language,
   utils::DbPool,
+  DbPoolRef,
 };
 use lemmy_utils::error::LemmyError;
 use serde::{Deserialize, Serialize};
@@ -33,7 +34,7 @@ pub(crate) struct LanguageTag {
 impl LanguageTag {
   pub(crate) async fn new_single(
     lang: LanguageId,
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
   ) -> Result<Option<LanguageTag>, LemmyError> {
     let lang = Language::read_from_id(pool, lang).await?;
 
@@ -50,7 +51,7 @@ impl LanguageTag {
 
   pub(crate) async fn new_multiple(
     lang_ids: Vec<LanguageId>,
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
   ) -> Result<Vec<LanguageTag>, LemmyError> {
     let mut langs = Vec::<Language>::new();
 
@@ -70,7 +71,7 @@ impl LanguageTag {
 
   pub(crate) async fn to_language_id_single(
     lang: Option<Self>,
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
   ) -> Result<Option<LanguageId>, LemmyError> {
     let identifier = lang.map(|l| l.identifier);
     let language = Language::read_id_from_code(pool, identifier.as_deref()).await?;
@@ -80,7 +81,7 @@ impl LanguageTag {
 
   pub(crate) async fn to_language_id_multiple(
     langs: Vec<Self>,
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
   ) -> Result<Vec<LanguageId>, LemmyError> {
     let mut language_ids = Vec::new();
 
diff --git a/crates/apub/src/protocol/objects/note.rs b/crates/apub/src/protocol/objects/note.rs
index de90636e6..f594c14e4 100644
--- a/crates/apub/src/protocol/objects/note.rs
+++ b/crates/apub/src/protocol/objects/note.rs
@@ -64,7 +64,7 @@ impl Note {
       PostOrComment::Post(p) => Ok((p.clone(), None)),
       PostOrComment::Comment(c) => {
         let post_id = c.post_id;
-        let post = Post::read(context.pool(), post_id).await?;
+        let post = Post::read(&mut context.pool(), post_id).await?;
         Ok((post.into(), Some(c.clone())))
       }
     }
@@ -75,7 +75,7 @@ impl Note {
 impl InCommunity for Note {
   async fn community(&self, context: &Data<LemmyContext>) -> Result<ApubCommunity, LemmyError> {
     let (post, _) = self.get_parents(context).await?;
-    let community = Community::read(context.pool(), post.community_id).await?;
+    let community = Community::read(&mut context.pool(), post.community_id).await?;
     if let Some(audience) = &self.audience {
       verify_community_matches(audience, community.actor_id.clone())?;
     }
diff --git a/crates/db_schema/src/aggregates/comment_aggregates.rs b/crates/db_schema/src/aggregates/comment_aggregates.rs
index 5a5550a2e..0ff399f0c 100644
--- a/crates/db_schema/src/aggregates/comment_aggregates.rs
+++ b/crates/db_schema/src/aggregates/comment_aggregates.rs
@@ -2,22 +2,21 @@ use crate::{
   aggregates::structs::CommentAggregates,
   newtypes::CommentId,
   schema::comment_aggregates,
-  utils::{functions::hot_rank, get_conn, DbPool},
+  utils::{functions::hot_rank, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl CommentAggregates {
-  pub async fn read(pool: &DbPool, comment_id: CommentId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, comment_id: CommentId) -> Result<Self, Error> {
+    let conn = pool;
     comment_aggregates::table
       .filter(comment_aggregates::comment_id.eq(comment_id))
       .first::<Self>(conn)
       .await
   }
 
-  pub async fn update_hot_rank(pool: &DbPool, comment_id: CommentId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn update_hot_rank(pool: DbPoolRef<'_>, comment_id: CommentId) -> Result<Self, Error> {
+    let conn = pool;
 
     diesel::update(comment_aggregates::table)
       .filter(comment_aggregates::comment_id.eq(comment_id))
@@ -49,7 +48,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/aggregates/community_aggregates.rs b/crates/db_schema/src/aggregates/community_aggregates.rs
index 2c2eaa781..1c03c8c86 100644
--- a/crates/db_schema/src/aggregates/community_aggregates.rs
+++ b/crates/db_schema/src/aggregates/community_aggregates.rs
@@ -2,14 +2,13 @@ use crate::{
   aggregates::structs::CommunityAggregates,
   newtypes::CommunityId,
   schema::community_aggregates,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl CommunityAggregates {
-  pub async fn read(pool: &DbPool, community_id: CommunityId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, community_id: CommunityId) -> Result<Self, Error> {
+    let conn = pool;
     community_aggregates::table
       .filter(community_aggregates::community_id.eq(community_id))
       .first::<Self>(conn)
@@ -36,7 +35,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/aggregates/person_aggregates.rs b/crates/db_schema/src/aggregates/person_aggregates.rs
index 295f1bfbb..7c85da9d9 100644
--- a/crates/db_schema/src/aggregates/person_aggregates.rs
+++ b/crates/db_schema/src/aggregates/person_aggregates.rs
@@ -2,14 +2,13 @@ use crate::{
   aggregates::structs::PersonAggregates,
   newtypes::PersonId,
   schema::person_aggregates,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl PersonAggregates {
-  pub async fn read(pool: &DbPool, person_id: PersonId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Self, Error> {
+    let conn = pool;
     person_aggregates::table
       .filter(person_aggregates::person_id.eq(person_id))
       .first::<Self>(conn)
@@ -36,7 +35,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/aggregates/person_post_aggregates.rs b/crates/db_schema/src/aggregates/person_post_aggregates.rs
index 5fe1aacff..cf55f49c6 100644
--- a/crates/db_schema/src/aggregates/person_post_aggregates.rs
+++ b/crates/db_schema/src/aggregates/person_post_aggregates.rs
@@ -3,14 +3,13 @@ use crate::{
   diesel::BoolExpressionMethods,
   newtypes::{PersonId, PostId},
   schema::person_post_aggregates::dsl::{person_id, person_post_aggregates, post_id},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl PersonPostAggregates {
-  pub async fn upsert(pool: &DbPool, form: &PersonPostAggregatesForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn upsert(pool: DbPoolRef<'_>, form: &PersonPostAggregatesForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(person_post_aggregates)
       .values(form)
       .on_conflict((person_id, post_id))
@@ -19,8 +18,12 @@ impl PersonPostAggregates {
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn read(pool: &DbPool, person_id_: PersonId, post_id_: PostId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(
+    pool: DbPoolRef<'_>,
+    person_id_: PersonId,
+    post_id_: PostId,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     person_post_aggregates
       .filter(post_id.eq(post_id_).and(person_id.eq(person_id_)))
       .first::<Self>(conn)
diff --git a/crates/db_schema/src/aggregates/post_aggregates.rs b/crates/db_schema/src/aggregates/post_aggregates.rs
index 176f694a7..4c73bfbdc 100644
--- a/crates/db_schema/src/aggregates/post_aggregates.rs
+++ b/crates/db_schema/src/aggregates/post_aggregates.rs
@@ -2,22 +2,21 @@ use crate::{
   aggregates::structs::PostAggregates,
   newtypes::PostId,
   schema::post_aggregates,
-  utils::{functions::hot_rank, get_conn, DbPool},
+  utils::{functions::hot_rank, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl PostAggregates {
-  pub async fn read(pool: &DbPool, post_id: PostId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, post_id: PostId) -> Result<Self, Error> {
+    let conn = pool;
     post_aggregates::table
       .filter(post_aggregates::post_id.eq(post_id))
       .first::<Self>(conn)
       .await
   }
 
-  pub async fn update_hot_rank(pool: &DbPool, post_id: PostId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn update_hot_rank(pool: DbPoolRef<'_>, post_id: PostId) -> Result<Self, Error> {
+    let conn = pool;
 
     diesel::update(post_aggregates::table)
       .filter(post_aggregates::post_id.eq(post_id))
@@ -52,7 +51,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/aggregates/site_aggregates.rs b/crates/db_schema/src/aggregates/site_aggregates.rs
index 719beb8f7..462984773 100644
--- a/crates/db_schema/src/aggregates/site_aggregates.rs
+++ b/crates/db_schema/src/aggregates/site_aggregates.rs
@@ -1,14 +1,13 @@
 use crate::{
   aggregates::structs::SiteAggregates,
   schema::site_aggregates,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::result::Error;
-use diesel_async::RunQueryDsl;
 
 impl SiteAggregates {
-  pub async fn read(pool: &DbPool) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>) -> Result<Self, Error> {
+    let conn = pool;
     site_aggregates::table.first::<Self>(conn).await
   }
 }
@@ -33,7 +32,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/activity.rs b/crates/db_schema/src/impls/activity.rs
index 9187e736c..04bd9f0ad 100644
--- a/crates/db_schema/src/impls/activity.rs
+++ b/crates/db_schema/src/impls/activity.rs
@@ -3,23 +3,22 @@ use crate::{
   schema::activity::dsl::{activity, ap_id},
   source::activity::{Activity, ActivityInsertForm, ActivityUpdateForm},
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for Activity {
   type InsertForm = ActivityInsertForm;
   type UpdateForm = ActivityUpdateForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, activity_id: i32) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, activity_id: i32) -> Result<Self, Error> {
+    let conn = pool;
     activity.find(activity_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, new_activity: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, new_activity: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(activity)
       .values(new_activity)
       .get_result::<Self>(conn)
@@ -27,18 +26,18 @@ impl Crud for Activity {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     activity_id: i32,
     new_activity: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(activity.find(activity_id))
       .set(new_activity)
       .get_result::<Self>(conn)
       .await
   }
-  async fn delete(pool: &DbPool, activity_id: i32) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, activity_id: i32) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(activity.find(activity_id))
       .execute(conn)
       .await
@@ -46,8 +45,11 @@ impl Crud for Activity {
 }
 
 impl Activity {
-  pub async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Activity, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: &DbUrl,
+  ) -> Result<Activity, Error> {
+    let conn = pool;
     activity
       .filter(ap_id.eq(object_id))
       .first::<Self>(conn)
@@ -74,7 +76,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/actor_language.rs b/crates/db_schema/src/impls/actor_language.rs
index dbb9c70fe..66ab8fcaa 100644
--- a/crates/db_schema/src/impls/actor_language.rs
+++ b/crates/db_schema/src/impls/actor_language.rs
@@ -14,7 +14,7 @@ use crate::{
     language::Language,
     site::Site,
   },
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   delete,
@@ -25,11 +25,7 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::{
-  pooled_connection::deadpool::Object as PooledConnection,
-  AsyncPgConnection,
-  RunQueryDsl,
-};
+use diesel_async::{pooled_connection::deadpool::Object as PooledConnection, AsyncPgConnection};
 use lemmy_utils::error::LemmyError;
 use tokio::sync::OnceCell;
 
@@ -37,7 +33,7 @@ pub const UNDETERMINED_ID: LanguageId = LanguageId(0);
 
 impl LocalUserLanguage {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_local_user_id: LocalUserId,
   ) -> Result<Vec<LanguageId>, Error> {
     use crate::schema::local_user_language::dsl::{
@@ -45,7 +41,7 @@ impl LocalUserLanguage {
       local_user_id,
       local_user_language,
     };
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     conn
       .build_transaction()
@@ -67,11 +63,11 @@ impl LocalUserLanguage {
   ///
   /// If no language_id vector is given, it will show all languages
   pub async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     language_ids: Vec<LanguageId>,
     for_local_user_id: LocalUserId,
   ) -> Result<(), Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let mut lang_ids = convert_update_languages(conn, language_ids).await?;
 
     // No need to update if languages are unchanged
@@ -118,8 +114,8 @@ impl LocalUserLanguage {
 }
 
 impl SiteLanguage {
-  pub async fn read_local_raw(pool: &DbPool) -> Result<Vec<LanguageId>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_local_raw(pool: DbPoolRef<'_>) -> Result<Vec<LanguageId>, Error> {
+    let conn = pool;
     site::table
       .inner_join(local_site::table)
       .inner_join(site_language::table)
@@ -141,19 +137,19 @@ impl SiteLanguage {
       .await
   }
 
-  pub async fn read(pool: &DbPool, for_site_id: SiteId) -> Result<Vec<LanguageId>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, for_site_id: SiteId) -> Result<Vec<LanguageId>, Error> {
+    let conn = pool;
     let langs = Self::read_raw(conn, for_site_id).await?;
 
     convert_read_languages(conn, langs).await
   }
 
   pub async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     language_ids: Vec<LanguageId>,
     site: &Site,
   ) -> Result<(), Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let for_site_id = site.id;
     let instance_id = site.instance_id;
     let lang_ids = convert_update_languages(conn, language_ids).await?;
@@ -198,12 +194,12 @@ impl SiteLanguage {
 impl CommunityLanguage {
   /// Returns true if the given language is one of configured languages for given community
   pub async fn is_allowed_community_language(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_language_id: Option<LanguageId>,
     for_community_id: CommunityId,
   ) -> Result<(), LemmyError> {
     use crate::schema::community_language::dsl::{community_id, community_language, language_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     if let Some(for_language_id) = for_language_id {
       let is_allowed = select(exists(
@@ -228,10 +224,7 @@ impl CommunityLanguage {
   /// also part of site languages. This is because post/comment language is only checked against
   /// community language, and it shouldnt be possible to post content in languages which are not
   /// allowed by local site.
-  async fn limit_languages(
-    conn: &mut AsyncPgConnection,
-    for_instance_id: InstanceId,
-  ) -> Result<(), Error> {
+  async fn limit_languages(conn: DbPoolRef<'_>, for_instance_id: InstanceId) -> Result<(), Error> {
     use crate::schema::{
       community::dsl as c,
       community_language::dsl as cl,
@@ -268,20 +261,20 @@ impl CommunityLanguage {
   }
 
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_community_id: CommunityId,
   ) -> Result<Vec<LanguageId>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let langs = Self::read_raw(conn, for_community_id).await?;
     convert_read_languages(conn, langs).await
   }
 
   pub async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     mut language_ids: Vec<LanguageId>,
     for_community_id: CommunityId,
   ) -> Result<(), Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     if language_ids.is_empty() {
       language_ids = SiteLanguage::read_local_raw(pool).await?;
     }
@@ -321,12 +314,12 @@ impl CommunityLanguage {
 }
 
 pub async fn default_post_language(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   community_id: CommunityId,
   local_user_id: LocalUserId,
 ) -> Result<Option<LanguageId>, Error> {
   use crate::schema::{community_language::dsl as cl, local_user_language::dsl as ul};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
   let mut intersection = ul::local_user_language
     .inner_join(cl::community_language.on(ul::language_id.eq(cl::language_id)))
     .filter(ul::local_user_id.eq(local_user_id))
@@ -347,7 +340,7 @@ pub async fn default_post_language(
 
 /// If no language is given, set all languages
 async fn convert_update_languages(
-  conn: &mut AsyncPgConnection,
+  conn: DbPoolRef<'_>,
   language_ids: Vec<LanguageId>,
 ) -> Result<Vec<LanguageId>, Error> {
   if language_ids.is_empty() {
@@ -365,7 +358,7 @@ async fn convert_update_languages(
 
 /// If all languages are returned, return empty vec instead
 async fn convert_read_languages(
-  conn: &mut AsyncPgConnection,
+  conn: DbPoolRef<'_>,
   language_ids: Vec<LanguageId>,
 ) -> Result<Vec<LanguageId>, Error> {
   static ALL_LANGUAGES_COUNT: OnceCell<usize> = OnceCell::const_new();
@@ -396,9 +389,9 @@ mod tests {
       convert_read_languages,
       convert_update_languages,
       default_post_language,
-      get_conn,
       CommunityLanguage,
       DbPool,
+      DbPoolRef,
       Language,
       LanguageId,
       LocalUserLanguage,
@@ -419,7 +412,7 @@ mod tests {
   };
   use serial_test::serial;
 
-  async fn test_langs1(pool: &DbPool) -> Vec<LanguageId> {
+  async fn test_langs1(pool: DbPoolRef<'_>) -> Vec<LanguageId> {
     vec![
       Language::read_id_from_code(pool, Some("en"))
         .await
@@ -435,7 +428,7 @@ mod tests {
         .unwrap(),
     ]
   }
-  async fn test_langs2(pool: &DbPool) -> Vec<LanguageId> {
+  async fn test_langs2(pool: DbPoolRef<'_>) -> Vec<LanguageId> {
     vec![
       Language::read_id_from_code(pool, Some("fi"))
         .await
@@ -448,7 +441,7 @@ mod tests {
     ]
   }
 
-  async fn create_test_site(pool: &DbPool) -> (Site, Instance) {
+  async fn create_test_site(pool: DbPoolRef<'_>) -> (Site, Instance) {
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
       .unwrap();
@@ -469,10 +462,10 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_convert_update_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     // call with empty vec, returns all languages
-    let conn = &mut get_conn(pool).await.unwrap();
+    let conn = pool;
     let converted1 = convert_update_languages(conn, vec![]).await.unwrap();
     assert_eq!(184, converted1.len());
 
@@ -487,10 +480,10 @@ mod tests {
   #[serial]
   async fn test_convert_read_languages() {
     use crate::schema::language::dsl::{id, language};
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     // call with all languages, returns empty vec
-    let conn = &mut get_conn(pool).await.unwrap();
+    let conn = pool;
     let all_langs = language.select(id).get_results(conn).await.unwrap();
     let converted1: Vec<LanguageId> = convert_read_languages(conn, all_langs).await.unwrap();
     assert_eq!(0, converted1.len());
@@ -506,7 +499,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_site_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let (site, instance) = create_test_site(pool).await;
     let site_languages1 = SiteLanguage::read_local_raw(pool).await.unwrap();
@@ -530,7 +523,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_user_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let (site, instance) = create_test_site(pool).await;
     let mut test_langs = test_langs1(pool).await;
@@ -576,7 +569,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_community_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let (site, instance) = create_test_site(pool).await;
     let test_langs = test_langs1(pool).await;
     SiteLanguage::update(pool, test_langs.clone(), &site)
@@ -637,7 +630,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_default_post_language() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let (site, instance) = create_test_site(pool).await;
     let test_langs = test_langs1(pool).await;
     let test_langs2 = test_langs2(pool).await;
diff --git a/crates/db_schema/src/impls/captcha_answer.rs b/crates/db_schema/src/impls/captcha_answer.rs
index de5fac65e..23caba6f3 100644
--- a/crates/db_schema/src/impls/captcha_answer.rs
+++ b/crates/db_schema/src/impls/captcha_answer.rs
@@ -1,7 +1,7 @@
 use crate::{
   schema::captcha_answer::dsl::{answer, captcha_answer, uuid},
   source::captcha_answer::{CaptchaAnswer, CaptchaAnswerForm, CheckCaptchaAnswer},
-  utils::{functions::lower, get_conn, DbPool},
+  utils::{functions::lower, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   delete,
@@ -12,11 +12,10 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 
 impl CaptchaAnswer {
-  pub async fn insert(pool: &DbPool, captcha: &CaptchaAnswerForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn insert(pool: DbPoolRef<'_>, captcha: &CaptchaAnswerForm) -> Result<Self, Error> {
+    let conn = pool;
 
     insert_into(captcha_answer)
       .values(captcha)
@@ -24,8 +23,11 @@ impl CaptchaAnswer {
       .await
   }
 
-  pub async fn check_captcha(pool: &DbPool, to_check: CheckCaptchaAnswer) -> Result<bool, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn check_captcha(
+    pool: DbPoolRef<'_>,
+    to_check: CheckCaptchaAnswer,
+  ) -> Result<bool, Error> {
+    let conn = pool;
 
     // fetch requested captcha
     let captcha_exists = select(exists(
@@ -56,7 +58,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_captcha_happy_path() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted = CaptchaAnswer::insert(
       pool,
@@ -83,7 +85,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_captcha_repeat_answer_fails() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted = CaptchaAnswer::insert(
       pool,
diff --git a/crates/db_schema/src/impls/comment.rs b/crates/db_schema/src/impls/comment.rs
index ea66347db..852e80d13 100644
--- a/crates/db_schema/src/impls/comment.rs
+++ b/crates/db_schema/src/impls/comment.rs
@@ -11,7 +11,7 @@ use crate::{
     CommentUpdateForm,
   },
   traits::{Crud, Likeable, Saveable},
-  utils::{get_conn, naive_now, DbPool, DELETED_REPLACEMENT_TEXT},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl, DELETED_REPLACEMENT_TEXT},
 };
 use diesel::{
   dsl::{insert_into, sql_query},
@@ -19,16 +19,15 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use diesel_ltree::Ltree;
 use url::Url;
 
 impl Comment {
   pub async fn permadelete_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     diesel::update(comment.filter(creator_id.eq(for_creator_id)))
       .set((
@@ -41,11 +40,11 @@ impl Comment {
   }
 
   pub async fn update_removed_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
     new_removed: bool,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(comment.filter(creator_id.eq(for_creator_id)))
       .set((removed.eq(new_removed), updated.eq(naive_now())))
       .get_results::<Self>(conn)
@@ -53,11 +52,11 @@ impl Comment {
   }
 
   pub async fn create(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     comment_form: &CommentInsertForm,
     parent_path: Option<&Ltree>,
   ) -> Result<Comment, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     // Insert, to get the id
     let inserted_comment = insert_into(comment)
@@ -123,8 +122,11 @@ where ca.comment_id = c.id"
       inserted_comment
     }
   }
-  pub async fn read_from_apub_id(pool: &DbPool, object_id: Url) -> Result<Option<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: Url,
+  ) -> Result<Option<Self>, Error> {
+    let conn = pool;
     let object_id: DbUrl = object_id.into();
     Ok(
       comment
@@ -153,27 +155,27 @@ impl Crud for Comment {
   type InsertForm = CommentInsertForm;
   type UpdateForm = CommentUpdateForm;
   type IdType = CommentId;
-  async fn read(pool: &DbPool, comment_id: CommentId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, comment_id: CommentId) -> Result<Self, Error> {
+    let conn = pool;
     comment.find(comment_id).first::<Self>(conn).await
   }
 
-  async fn delete(pool: &DbPool, comment_id: CommentId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, comment_id: CommentId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(comment.find(comment_id)).execute(conn).await
   }
 
   /// This is unimplemented, use [[Comment::create]]
-  async fn create(_pool: &DbPool, _comment_form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn create(_pool: DbPoolRef<'_>, _comment_form: &Self::InsertForm) -> Result<Self, Error> {
     unimplemented!();
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     comment_id: CommentId,
     comment_form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(comment.find(comment_id))
       .set(comment_form)
       .get_result::<Self>(conn)
@@ -185,9 +187,9 @@ impl Crud for Comment {
 impl Likeable for CommentLike {
   type Form = CommentLikeForm;
   type IdType = CommentId;
-  async fn like(pool: &DbPool, comment_like_form: &CommentLikeForm) -> Result<Self, Error> {
+  async fn like(pool: DbPoolRef<'_>, comment_like_form: &CommentLikeForm) -> Result<Self, Error> {
     use crate::schema::comment_like::dsl::{comment_id, comment_like, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(comment_like)
       .values(comment_like_form)
       .on_conflict((comment_id, person_id))
@@ -197,12 +199,12 @@ impl Likeable for CommentLike {
       .await
   }
   async fn remove(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_id_: PersonId,
     comment_id_: CommentId,
   ) -> Result<usize, Error> {
     use crate::schema::comment_like::dsl::{comment_id, comment_like, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       comment_like
         .filter(comment_id.eq(comment_id_))
@@ -216,9 +218,9 @@ impl Likeable for CommentLike {
 #[async_trait]
 impl Saveable for CommentSaved {
   type Form = CommentSavedForm;
-  async fn save(pool: &DbPool, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> {
+  async fn save(pool: DbPoolRef<'_>, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> {
     use crate::schema::comment_saved::dsl::{comment_id, comment_saved, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(comment_saved)
       .values(comment_saved_form)
       .on_conflict((comment_id, person_id))
@@ -227,9 +229,12 @@ impl Saveable for CommentSaved {
       .get_result::<Self>(conn)
       .await
   }
-  async fn unsave(pool: &DbPool, comment_saved_form: &CommentSavedForm) -> Result<usize, Error> {
+  async fn unsave(
+    pool: DbPoolRef<'_>,
+    comment_saved_form: &CommentSavedForm,
+  ) -> Result<usize, Error> {
     use crate::schema::comment_saved::dsl::{comment_id, comment_saved, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       comment_saved
         .filter(comment_id.eq(comment_saved_form.comment_id))
@@ -268,7 +273,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/comment_reply.rs b/crates/db_schema/src/impls/comment_reply.rs
index 2489c982f..d5629727c 100644
--- a/crates/db_schema/src/impls/comment_reply.rs
+++ b/crates/db_schema/src/impls/comment_reply.rs
@@ -3,26 +3,28 @@ use crate::{
   schema::comment_reply::dsl::{comment_id, comment_reply, read, recipient_id},
   source::comment_reply::{CommentReply, CommentReplyInsertForm, CommentReplyUpdateForm},
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for CommentReply {
   type InsertForm = CommentReplyInsertForm;
   type UpdateForm = CommentReplyUpdateForm;
   type IdType = CommentReplyId;
-  async fn read(pool: &DbPool, comment_reply_id: CommentReplyId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, comment_reply_id: CommentReplyId) -> Result<Self, Error> {
+    let conn = pool;
     comment_reply
       .find(comment_reply_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, comment_reply_form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(
+    pool: DbPoolRef<'_>,
+    comment_reply_form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
+    let conn = pool;
 
     // since the return here isnt utilized, we dont need to do an update
     // but get_result doesnt return the existing row here
@@ -36,11 +38,11 @@ impl Crud for CommentReply {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     comment_reply_id: CommentReplyId,
     comment_reply_form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(comment_reply.find(comment_reply_id))
       .set(comment_reply_form)
       .get_result::<Self>(conn)
@@ -50,10 +52,10 @@ impl Crud for CommentReply {
 
 impl CommentReply {
   pub async fn mark_all_as_read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_recipient_id: PersonId,
   ) -> Result<Vec<CommentReply>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(
       comment_reply
         .filter(recipient_id.eq(for_recipient_id))
@@ -64,8 +66,11 @@ impl CommentReply {
     .await
   }
 
-  pub async fn read_by_comment(pool: &DbPool, for_comment_id: CommentId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_by_comment(
+    pool: DbPoolRef<'_>,
+    for_comment_id: CommentId,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     comment_reply
       .filter(comment_id.eq(for_comment_id))
       .first::<Self>(conn)
@@ -92,7 +97,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/comment_report.rs b/crates/db_schema/src/impls/comment_report.rs
index 18cf83a72..80e51b881 100644
--- a/crates/db_schema/src/impls/comment_report.rs
+++ b/crates/db_schema/src/impls/comment_report.rs
@@ -3,7 +3,7 @@ use crate::{
   schema::comment_report::dsl::{comment_report, resolved, resolver_id, updated},
   source::comment_report::{CommentReport, CommentReportForm},
   traits::Reportable,
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   dsl::{insert_into, update},
@@ -11,7 +11,6 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Reportable for CommentReport {
@@ -21,8 +20,11 @@ impl Reportable for CommentReport {
   ///
   /// * `conn` - the postgres connection
   /// * `comment_report_form` - the filled CommentReportForm to insert
-  async fn report(pool: &DbPool, comment_report_form: &CommentReportForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn report(
+    pool: DbPoolRef<'_>,
+    comment_report_form: &CommentReportForm,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(comment_report)
       .values(comment_report_form)
       .get_result::<Self>(conn)
@@ -35,11 +37,11 @@ impl Reportable for CommentReport {
   /// * `report_id` - the id of the report to resolve
   /// * `by_resolver_id` - the id of the user resolving the report
   async fn resolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id_: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(comment_report.find(report_id_))
       .set((
         resolved.eq(true),
@@ -56,11 +58,11 @@ impl Reportable for CommentReport {
   /// * `report_id` - the id of the report to unresolve
   /// * `by_resolver_id` - the id of the user unresolving the report
   async fn unresolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id_: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(comment_report.find(report_id_))
       .set((
         resolved.eq(false),
diff --git a/crates/db_schema/src/impls/community.rs b/crates/db_schema/src/impls/community.rs
index ad9e6d47d..c53c8f1aa 100644
--- a/crates/db_schema/src/impls/community.rs
+++ b/crates/db_schema/src/impls/community.rs
@@ -16,34 +16,33 @@ use crate::{
     },
   },
   traits::{ApubActor, Bannable, Crud, Followable, Joinable},
-  utils::{functions::lower, get_conn, DbPool},
+  utils::{functions::lower, DbPool, DbPoolRef, RunQueryDsl},
   SubscribedType,
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for Community {
   type InsertForm = CommunityInsertForm;
   type UpdateForm = CommunityUpdateForm;
   type IdType = CommunityId;
-  async fn read(pool: &DbPool, community_id: CommunityId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, community_id: CommunityId) -> Result<Self, Error> {
+    let conn = pool;
     community::table
       .find(community_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn delete(pool: &DbPool, community_id: CommunityId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, community_id: CommunityId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(community::table.find(community_id))
       .execute(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     let is_new_community = match &form.actor_id {
       Some(id) => Community::read_from_apub_id(pool, id).await?.is_none(),
       None => true,
@@ -67,11 +66,11 @@ impl Crud for Community {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_id: CommunityId,
     form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(community::table.find(community_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -83,11 +82,11 @@ impl Crud for Community {
 impl Joinable for CommunityModerator {
   type Form = CommunityModeratorForm;
   async fn join(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_moderator_form: &CommunityModeratorForm,
   ) -> Result<Self, Error> {
     use crate::schema::community_moderator::dsl::community_moderator;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(community_moderator)
       .values(community_moderator_form)
       .get_result::<Self>(conn)
@@ -95,11 +94,11 @@ impl Joinable for CommunityModerator {
   }
 
   async fn leave(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_moderator_form: &CommunityModeratorForm,
   ) -> Result<usize, Error> {
     use crate::schema::community_moderator::dsl::{community_id, community_moderator, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       community_moderator
         .filter(community_id.eq(community_moderator_form.community_id))
@@ -118,12 +117,12 @@ pub enum CollectionType {
 impl Community {
   /// Get the community which has a given moderators or featured url, also return the collection type
   pub async fn get_by_collection_url(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     url: &DbUrl,
   ) -> Result<(Community, CollectionType), Error> {
     use crate::schema::community::dsl::{featured_url, moderators_url};
     use CollectionType::*;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let res = community::table
       .filter(moderators_url.eq(url))
       .first::<Self>(conn)
@@ -144,11 +143,11 @@ impl Community {
 
 impl CommunityModerator {
   pub async fn delete_for_community(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_community_id: CommunityId,
   ) -> Result<usize, Error> {
     use crate::schema::community_moderator::dsl::{community_id, community_moderator};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     diesel::delete(community_moderator.filter(community_id.eq(for_community_id)))
       .execute(conn)
@@ -156,22 +155,22 @@ impl CommunityModerator {
   }
 
   pub async fn leave_all_communities(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_person_id: PersonId,
   ) -> Result<usize, Error> {
     use crate::schema::community_moderator::dsl::{community_moderator, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(community_moderator.filter(person_id.eq(for_person_id)))
       .execute(conn)
       .await
   }
 
   pub async fn get_person_moderated_communities(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_person_id: PersonId,
   ) -> Result<Vec<CommunityId>, Error> {
     use crate::schema::community_moderator::dsl::{community_id, community_moderator, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     community_moderator
       .filter(person_id.eq(for_person_id))
       .select(community_id)
@@ -184,11 +183,11 @@ impl CommunityModerator {
 impl Bannable for CommunityPersonBan {
   type Form = CommunityPersonBanForm;
   async fn ban(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_person_ban_form: &CommunityPersonBanForm,
   ) -> Result<Self, Error> {
     use crate::schema::community_person_ban::dsl::{community_id, community_person_ban, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(community_person_ban)
       .values(community_person_ban_form)
       .on_conflict((community_id, person_id))
@@ -199,11 +198,11 @@ impl Bannable for CommunityPersonBan {
   }
 
   async fn unban(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_person_ban_form: &CommunityPersonBanForm,
   ) -> Result<usize, Error> {
     use crate::schema::community_person_ban::dsl::{community_id, community_person_ban, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       community_person_ban
         .filter(community_id.eq(community_person_ban_form.community_id))
@@ -233,9 +232,9 @@ impl CommunityFollower {
 #[async_trait]
 impl Followable for CommunityFollower {
   type Form = CommunityFollowerForm;
-  async fn follow(pool: &DbPool, form: &CommunityFollowerForm) -> Result<Self, Error> {
+  async fn follow(pool: DbPoolRef<'_>, form: &CommunityFollowerForm) -> Result<Self, Error> {
     use crate::schema::community_follower::dsl::{community_follower, community_id, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(community_follower)
       .values(form)
       .on_conflict((community_id, person_id))
@@ -245,7 +244,7 @@ impl Followable for CommunityFollower {
       .await
   }
   async fn follow_accepted(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_id_: CommunityId,
     person_id_: PersonId,
   ) -> Result<Self, Error> {
@@ -255,7 +254,7 @@ impl Followable for CommunityFollower {
       pending,
       person_id,
     };
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(
       community_follower
         .filter(community_id.eq(community_id_))
@@ -265,9 +264,9 @@ impl Followable for CommunityFollower {
     .get_result::<Self>(conn)
     .await
   }
-  async fn unfollow(pool: &DbPool, form: &CommunityFollowerForm) -> Result<usize, Error> {
+  async fn unfollow(pool: DbPoolRef<'_>, form: &CommunityFollowerForm) -> Result<usize, Error> {
     use crate::schema::community_follower::dsl::{community_follower, community_id, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       community_follower
         .filter(community_id.eq(&form.community_id))
@@ -280,8 +279,11 @@ impl Followable for CommunityFollower {
 
 #[async_trait]
 impl ApubActor for Community {
-  async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Option<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: &DbUrl,
+  ) -> Result<Option<Self>, Error> {
+    let conn = pool;
     Ok(
       community::table
         .filter(community::actor_id.eq(object_id))
@@ -293,11 +295,11 @@ impl ApubActor for Community {
   }
 
   async fn read_from_name(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_name: &str,
     include_deleted: bool,
   ) -> Result<Community, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let mut q = community::table
       .into_boxed()
       .filter(community::local.eq(true))
@@ -311,11 +313,11 @@ impl ApubActor for Community {
   }
 
   async fn read_from_name_and_domain(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_name: &str,
     for_domain: &str,
   ) -> Result<Community, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     community::table
       .inner_join(instance::table)
       .filter(lower(community::name).eq(community_name.to_lowercase()))
@@ -352,7 +354,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/community_block.rs b/crates/db_schema/src/impls/community_block.rs
index c1f35e625..0facd3ed6 100644
--- a/crates/db_schema/src/impls/community_block.rs
+++ b/crates/db_schema/src/impls/community_block.rs
@@ -2,16 +2,15 @@ use crate::{
   schema::community_block::dsl::{community_block, community_id, person_id},
   source::community_block::{CommunityBlock, CommunityBlockForm},
   traits::Blockable,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Blockable for CommunityBlock {
   type Form = CommunityBlockForm;
-  async fn block(pool: &DbPool, community_block_form: &Self::Form) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn block(pool: DbPoolRef<'_>, community_block_form: &Self::Form) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(community_block)
       .values(community_block_form)
       .on_conflict((person_id, community_id))
@@ -20,8 +19,8 @@ impl Blockable for CommunityBlock {
       .get_result::<Self>(conn)
       .await
   }
-  async fn unblock(pool: &DbPool, community_block_form: &Self::Form) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn unblock(pool: DbPoolRef<'_>, community_block_form: &Self::Form) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(
       community_block
         .filter(person_id.eq(community_block_form.person_id))
diff --git a/crates/db_schema/src/impls/custom_emoji.rs b/crates/db_schema/src/impls/custom_emoji.rs
index cce35dfc7..a9923b8f6 100644
--- a/crates/db_schema/src/impls/custom_emoji.rs
+++ b/crates/db_schema/src/impls/custom_emoji.rs
@@ -8,32 +8,31 @@ use crate::{
     custom_emoji::{CustomEmoji, CustomEmojiInsertForm, CustomEmojiUpdateForm},
     custom_emoji_keyword::{CustomEmojiKeyword, CustomEmojiKeywordInsertForm},
   },
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl CustomEmoji {
-  pub async fn create(pool: &DbPool, form: &CustomEmojiInsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn create(pool: DbPoolRef<'_>, form: &CustomEmojiInsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(custom_emoji)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
   pub async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     emoji_id: CustomEmojiId,
     form: &CustomEmojiUpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(custom_emoji.find(emoji_id))
       .set(form)
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn delete(pool: &DbPool, emoji_id: CustomEmojiId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete(pool: DbPoolRef<'_>, emoji_id: CustomEmojiId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(custom_emoji.find(emoji_id))
       .execute(conn)
       .await
@@ -42,17 +41,17 @@ impl CustomEmoji {
 
 impl CustomEmojiKeyword {
   pub async fn create(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     form: Vec<CustomEmojiKeywordInsertForm>,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(custom_emoji_keyword)
       .values(form)
       .get_results::<Self>(conn)
       .await
   }
-  pub async fn delete(pool: &DbPool, emoji_id: CustomEmojiId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete(pool: DbPoolRef<'_>, emoji_id: CustomEmojiId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(custom_emoji_keyword.filter(custom_emoji_id.eq(emoji_id)))
       .execute(conn)
       .await
diff --git a/crates/db_schema/src/impls/email_verification.rs b/crates/db_schema/src/impls/email_verification.rs
index af19bbba0..38e6087be 100644
--- a/crates/db_schema/src/impls/email_verification.rs
+++ b/crates/db_schema/src/impls/email_verification.rs
@@ -7,7 +7,7 @@ use crate::{
     verification_token,
   },
   source::email_verification::{EmailVerification, EmailVerificationForm},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   dsl::{now, IntervalDsl},
@@ -16,19 +16,18 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 
 impl EmailVerification {
-  pub async fn create(pool: &DbPool, form: &EmailVerificationForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn create(pool: DbPoolRef<'_>, form: &EmailVerificationForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(email_verification)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  pub async fn read_for_token(pool: &DbPool, token: &str) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_for_token(pool: DbPoolRef<'_>, token: &str) -> Result<Self, Error> {
+    let conn = pool;
     email_verification
       .filter(verification_token.eq(token))
       .filter(published.gt(now - 7.days()))
@@ -36,10 +35,10 @@ impl EmailVerification {
       .await
   }
   pub async fn delete_old_tokens_for_local_user(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     local_user_id_: LocalUserId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(email_verification.filter(local_user_id.eq(local_user_id_)))
       .execute(conn)
       .await
diff --git a/crates/db_schema/src/impls/federation_allowlist.rs b/crates/db_schema/src/impls/federation_allowlist.rs
index c71ffd1cf..0869045d6 100644
--- a/crates/db_schema/src/impls/federation_allowlist.rs
+++ b/crates/db_schema/src/impls/federation_allowlist.rs
@@ -4,14 +4,14 @@ use crate::{
     federation_allowlist::{FederationAllowList, FederationAllowListForm},
     instance::Instance,
   },
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use diesel_async::AsyncPgConnection;
 
 impl FederationAllowList {
-  pub async fn replace(pool: &DbPool, list_opt: Option<Vec<String>>) -> Result<(), Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn replace(pool: DbPoolRef<'_>, list_opt: Option<Vec<String>>) -> Result<(), Error> {
+    let conn = pool;
     conn
       .build_transaction()
       .run(|conn| {
@@ -58,7 +58,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_allowlist_insert_and_clear() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let domains = vec![
       "tld1.xyz".to_string(),
       "tld2.xyz".to_string(),
diff --git a/crates/db_schema/src/impls/federation_blocklist.rs b/crates/db_schema/src/impls/federation_blocklist.rs
index 917bf57a3..70e52c0ea 100644
--- a/crates/db_schema/src/impls/federation_blocklist.rs
+++ b/crates/db_schema/src/impls/federation_blocklist.rs
@@ -4,14 +4,14 @@ use crate::{
     federation_blocklist::{FederationBlockList, FederationBlockListForm},
     instance::Instance,
   },
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use diesel_async::AsyncPgConnection;
 
 impl FederationBlockList {
-  pub async fn replace(pool: &DbPool, list_opt: Option<Vec<String>>) -> Result<(), Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn replace(pool: DbPoolRef<'_>, list_opt: Option<Vec<String>>) -> Result<(), Error> {
+    let conn = pool;
     conn
       .build_transaction()
       .run(|conn| {
diff --git a/crates/db_schema/src/impls/instance.rs b/crates/db_schema/src/impls/instance.rs
index e5a8caba3..3e52d98a8 100644
--- a/crates/db_schema/src/impls/instance.rs
+++ b/crates/db_schema/src/impls/instance.rs
@@ -2,14 +2,14 @@ use crate::{
   newtypes::InstanceId,
   schema::{federation_allowlist, federation_blocklist, instance},
   source::instance::{Instance, InstanceForm},
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use diesel_async::AsyncPgConnection;
 
 impl Instance {
   pub(crate) async fn read_or_create_with_conn(
-    conn: &mut AsyncPgConnection,
+    conn: DbPoolRef<'_>,
     domain_: String,
   ) -> Result<Self, Error> {
     use crate::schema::instance::domain;
@@ -42,23 +42,23 @@ impl Instance {
 
   /// Attempt to read Instance column for the given domain. If it doesnt exist, insert a new one.
   /// There is no need for update as the domain of an existing instance cant change.
-  pub async fn read_or_create(pool: &DbPool, domain: String) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_or_create(pool: DbPoolRef<'_>, domain: String) -> Result<Self, Error> {
+    let conn = pool;
     Self::read_or_create_with_conn(conn, domain).await
   }
-  pub async fn delete(pool: &DbPool, instance_id: InstanceId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete(pool: DbPoolRef<'_>, instance_id: InstanceId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(instance::table.find(instance_id))
       .execute(conn)
       .await
   }
   #[cfg(test)]
-  pub async fn delete_all(pool: &DbPool) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete_all(pool: DbPoolRef<'_>) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(instance::table).execute(conn).await
   }
-  pub async fn allowlist(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn allowlist(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     instance::table
       .inner_join(federation_allowlist::table)
       .select(instance::all_columns)
@@ -66,8 +66,8 @@ impl Instance {
       .await
   }
 
-  pub async fn blocklist(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn blocklist(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     instance::table
       .inner_join(federation_blocklist::table)
       .select(instance::all_columns)
@@ -75,8 +75,8 @@ impl Instance {
       .await
   }
 
-  pub async fn linked(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn linked(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     instance::table
       .left_join(federation_blocklist::table)
       .filter(federation_blocklist::id.is_null())
diff --git a/crates/db_schema/src/impls/language.rs b/crates/db_schema/src/impls/language.rs
index da9e0ca9d..5092ff535 100644
--- a/crates/db_schema/src/impls/language.rs
+++ b/crates/db_schema/src/impls/language.rs
@@ -3,14 +3,14 @@ use crate::{
   newtypes::LanguageId,
   schema::language::dsl::{code, id, language},
   source::language::Language,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{result::Error, QueryDsl};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use diesel_async::AsyncPgConnection;
 
 impl Language {
-  pub async fn read_all(pool: &DbPool) -> Result<Vec<Language>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_all(pool: DbPoolRef<'_>) -> Result<Vec<Language>, Error> {
+    let conn = pool;
     Self::read_all_conn(conn).await
   }
 
@@ -18,18 +18,18 @@ impl Language {
     language.load::<Self>(conn).await
   }
 
-  pub async fn read_from_id(pool: &DbPool, id_: LanguageId) -> Result<Language, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_id(pool: DbPoolRef<'_>, id_: LanguageId) -> Result<Language, Error> {
+    let conn = pool;
     language.filter(id.eq(id_)).first::<Self>(conn).await
   }
 
   /// Attempts to find the given language code and return its ID. If not found, returns none.
   pub async fn read_id_from_code(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     code_: Option<&str>,
   ) -> Result<Option<LanguageId>, Error> {
     if let Some(code_) = code_ {
-      let conn = &mut get_conn(pool).await?;
+      let conn = pool;
       Ok(
         language
           .filter(code.eq(code_))
@@ -52,7 +52,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let all = Language::read_all(pool).await.unwrap();
 
diff --git a/crates/db_schema/src/impls/local_site.rs b/crates/db_schema/src/impls/local_site.rs
index b9e920d15..45a6b3427 100644
--- a/crates/db_schema/src/impls/local_site.rs
+++ b/crates/db_schema/src/impls/local_site.rs
@@ -1,32 +1,31 @@
 use crate::{
   schema::local_site::dsl::local_site,
   source::local_site::{LocalSite, LocalSiteInsertForm, LocalSiteUpdateForm},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error};
-use diesel_async::RunQueryDsl;
 
 impl LocalSite {
-  pub async fn create(pool: &DbPool, form: &LocalSiteInsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn create(pool: DbPoolRef<'_>, form: &LocalSiteInsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(local_site)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn read(pool: &DbPool) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>) -> Result<Self, Error> {
+    let conn = pool;
     local_site.first::<Self>(conn).await
   }
-  pub async fn update(pool: &DbPool, form: &LocalSiteUpdateForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn update(pool: DbPoolRef<'_>, form: &LocalSiteUpdateForm) -> Result<Self, Error> {
+    let conn = pool;
     diesel::update(local_site)
       .set(form)
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn delete(pool: &DbPool) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete(pool: DbPoolRef<'_>) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(local_site).execute(conn).await
   }
 }
diff --git a/crates/db_schema/src/impls/local_site_rate_limit.rs b/crates/db_schema/src/impls/local_site_rate_limit.rs
index b1af5f869..f6bfd852c 100644
--- a/crates/db_schema/src/impls/local_site_rate_limit.rs
+++ b/crates/db_schema/src/impls/local_site_rate_limit.rs
@@ -5,30 +5,35 @@ use crate::{
     LocalSiteRateLimitInsertForm,
     LocalSiteRateLimitUpdateForm,
   },
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error};
-use diesel_async::RunQueryDsl;
 
 impl LocalSiteRateLimit {
-  pub async fn read(pool: &DbPool) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>) -> Result<Self, Error> {
+    let conn = pool;
     local_site_rate_limit::table.first::<Self>(conn).await
   }
 
-  pub async fn create(pool: &DbPool, form: &LocalSiteRateLimitInsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn create(
+    pool: DbPoolRef<'_>,
+    form: &LocalSiteRateLimitInsertForm,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(local_site_rate_limit::table)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn update(pool: &DbPool, form: &LocalSiteRateLimitUpdateForm) -> Result<(), Error> {
+  pub async fn update(
+    pool: DbPoolRef<'_>,
+    form: &LocalSiteRateLimitUpdateForm,
+  ) -> Result<(), Error> {
     // avoid error "There are no changes to save. This query cannot be built"
     if form.is_empty() {
       return Ok(());
     }
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(local_site_rate_limit::table)
       .set(form)
       .get_result::<Self>(conn)
diff --git a/crates/db_schema/src/impls/local_user.rs b/crates/db_schema/src/impls/local_user.rs
index c8ae23627..8bff67db1 100644
--- a/crates/db_schema/src/impls/local_user.rs
+++ b/crates/db_schema/src/impls/local_user.rs
@@ -13,19 +13,18 @@ use crate::{
     local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
   },
   traits::Crud,
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use bcrypt::{hash, DEFAULT_COST};
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl LocalUser {
   pub async fn update_password(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     local_user_id: LocalUserId,
     new_password: &str,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let password_hash = hash(new_password, DEFAULT_COST).expect("Couldn't hash password");
 
     diesel::update(local_user.find(local_user_id))
@@ -37,8 +36,8 @@ impl LocalUser {
       .await
   }
 
-  pub async fn set_all_users_email_verified(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn set_all_users_email_verified(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     diesel::update(local_user)
       .set(email_verified.eq(true))
       .get_results::<Self>(conn)
@@ -46,18 +45,18 @@ impl LocalUser {
   }
 
   pub async fn set_all_users_registration_applications_accepted(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(local_user)
       .set(accepted_application.eq(true))
       .get_results::<Self>(conn)
       .await
   }
 
-  pub async fn is_email_taken(pool: &DbPool, email_: &str) -> Result<bool, Error> {
+  pub async fn is_email_taken(pool: DbPoolRef<'_>, email_: &str) -> Result<bool, Error> {
     use diesel::dsl::{exists, select};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     select(exists(local_user.filter(email.eq(email_))))
       .get_result(conn)
       .await
@@ -69,18 +68,18 @@ impl Crud for LocalUser {
   type InsertForm = LocalUserInsertForm;
   type UpdateForm = LocalUserUpdateForm;
   type IdType = LocalUserId;
-  async fn read(pool: &DbPool, local_user_id: LocalUserId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, local_user_id: LocalUserId) -> Result<Self, Error> {
+    let conn = pool;
     local_user.find(local_user_id).first::<Self>(conn).await
   }
-  async fn delete(pool: &DbPool, local_user_id: LocalUserId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, local_user_id: LocalUserId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(local_user.find(local_user_id))
       .execute(conn)
       .await
   }
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     let mut form_with_encrypted_password = form.clone();
     let password_hash =
       hash(&form.password_encrypted, DEFAULT_COST).expect("Couldn't hash password");
@@ -104,11 +103,11 @@ impl Crud for LocalUser {
     Ok(local_user_)
   }
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     local_user_id: LocalUserId,
     form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(local_user.find(local_user_id))
       .set(form)
       .get_result::<Self>(conn)
diff --git a/crates/db_schema/src/impls/moderator.rs b/crates/db_schema/src/impls/moderator.rs
index ab8398cf3..a57441dda 100644
--- a/crates/db_schema/src/impls/moderator.rs
+++ b/crates/db_schema/src/impls/moderator.rs
@@ -32,34 +32,37 @@ use crate::{
     ModTransferCommunityForm,
   },
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for ModRemovePost {
   type InsertForm = ModRemovePostForm;
   type UpdateForm = ModRemovePostForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_remove_post::dsl::mod_remove_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_remove_post.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModRemovePostForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModRemovePostForm) -> Result<Self, Error> {
     use crate::schema::mod_remove_post::dsl::mod_remove_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_remove_post)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModRemovePostForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModRemovePostForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_remove_post::dsl::mod_remove_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_remove_post.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -72,24 +75,28 @@ impl Crud for ModLockPost {
   type InsertForm = ModLockPostForm;
   type UpdateForm = ModLockPostForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_lock_post::dsl::mod_lock_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_lock_post.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModLockPostForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModLockPostForm) -> Result<Self, Error> {
     use crate::schema::mod_lock_post::dsl::mod_lock_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_lock_post)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModLockPostForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModLockPostForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_lock_post::dsl::mod_lock_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_lock_post.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -102,24 +109,28 @@ impl Crud for ModFeaturePost {
   type InsertForm = ModFeaturePostForm;
   type UpdateForm = ModFeaturePostForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_feature_post::dsl::mod_feature_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_feature_post.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModFeaturePostForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModFeaturePostForm) -> Result<Self, Error> {
     use crate::schema::mod_feature_post::dsl::mod_feature_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_feature_post)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModFeaturePostForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModFeaturePostForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_feature_post::dsl::mod_feature_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_feature_post.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -132,24 +143,28 @@ impl Crud for ModRemoveComment {
   type InsertForm = ModRemoveCommentForm;
   type UpdateForm = ModRemoveCommentForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_remove_comment::dsl::mod_remove_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_remove_comment.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModRemoveCommentForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModRemoveCommentForm) -> Result<Self, Error> {
     use crate::schema::mod_remove_comment::dsl::mod_remove_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_remove_comment)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModRemoveCommentForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModRemoveCommentForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_remove_comment::dsl::mod_remove_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_remove_comment.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -162,15 +177,15 @@ impl Crud for ModRemoveCommunity {
   type InsertForm = ModRemoveCommunityForm;
   type UpdateForm = ModRemoveCommunityForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_remove_community::dsl::mod_remove_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_remove_community.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModRemoveCommunityForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModRemoveCommunityForm) -> Result<Self, Error> {
     use crate::schema::mod_remove_community::dsl::mod_remove_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_remove_community)
       .values(form)
       .get_result::<Self>(conn)
@@ -178,12 +193,12 @@ impl Crud for ModRemoveCommunity {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_id: i32,
     form: &ModRemoveCommunityForm,
   ) -> Result<Self, Error> {
     use crate::schema::mod_remove_community::dsl::mod_remove_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_remove_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -196,18 +211,18 @@ impl Crud for ModBanFromCommunity {
   type InsertForm = ModBanFromCommunityForm;
   type UpdateForm = ModBanFromCommunityForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_ban_from_community::dsl::mod_ban_from_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_ban_from_community
       .find(from_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, form: &ModBanFromCommunityForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModBanFromCommunityForm) -> Result<Self, Error> {
     use crate::schema::mod_ban_from_community::dsl::mod_ban_from_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_ban_from_community)
       .values(form)
       .get_result::<Self>(conn)
@@ -215,12 +230,12 @@ impl Crud for ModBanFromCommunity {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_id: i32,
     form: &ModBanFromCommunityForm,
   ) -> Result<Self, Error> {
     use crate::schema::mod_ban_from_community::dsl::mod_ban_from_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_ban_from_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -233,24 +248,24 @@ impl Crud for ModBan {
   type InsertForm = ModBanForm;
   type UpdateForm = ModBanForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_ban::dsl::mod_ban;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_ban.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModBanForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModBanForm) -> Result<Self, Error> {
     use crate::schema::mod_ban::dsl::mod_ban;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_ban)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModBanForm) -> Result<Self, Error> {
+  async fn update(pool: DbPoolRef<'_>, from_id: i32, form: &ModBanForm) -> Result<Self, Error> {
     use crate::schema::mod_ban::dsl::mod_ban;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_ban.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -264,24 +279,28 @@ impl Crud for ModHideCommunity {
   type UpdateForm = ModHideCommunityForm;
   type IdType = i32;
 
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_hide_community::dsl::mod_hide_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_hide_community.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModHideCommunityForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModHideCommunityForm) -> Result<Self, Error> {
     use crate::schema::mod_hide_community::dsl::mod_hide_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_hide_community)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModHideCommunityForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModHideCommunityForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_hide_community::dsl::mod_hide_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_hide_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -294,24 +313,28 @@ impl Crud for ModAddCommunity {
   type InsertForm = ModAddCommunityForm;
   type UpdateForm = ModAddCommunityForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_add_community::dsl::mod_add_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_add_community.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModAddCommunityForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModAddCommunityForm) -> Result<Self, Error> {
     use crate::schema::mod_add_community::dsl::mod_add_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_add_community)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModAddCommunityForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &ModAddCommunityForm,
+  ) -> Result<Self, Error> {
     use crate::schema::mod_add_community::dsl::mod_add_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_add_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -324,18 +347,18 @@ impl Crud for ModTransferCommunity {
   type InsertForm = ModTransferCommunityForm;
   type UpdateForm = ModTransferCommunityForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_transfer_community::dsl::mod_transfer_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_transfer_community
       .find(from_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, form: &ModTransferCommunityForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModTransferCommunityForm) -> Result<Self, Error> {
     use crate::schema::mod_transfer_community::dsl::mod_transfer_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_transfer_community)
       .values(form)
       .get_result::<Self>(conn)
@@ -343,12 +366,12 @@ impl Crud for ModTransferCommunity {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_id: i32,
     form: &ModTransferCommunityForm,
   ) -> Result<Self, Error> {
     use crate::schema::mod_transfer_community::dsl::mod_transfer_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_transfer_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -361,24 +384,24 @@ impl Crud for ModAdd {
   type InsertForm = ModAddForm;
   type UpdateForm = ModAddForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::mod_add::dsl::mod_add;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     mod_add.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &ModAddForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &ModAddForm) -> Result<Self, Error> {
     use crate::schema::mod_add::dsl::mod_add;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(mod_add)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &ModAddForm) -> Result<Self, Error> {
+  async fn update(pool: DbPoolRef<'_>, from_id: i32, form: &ModAddForm) -> Result<Self, Error> {
     use crate::schema::mod_add::dsl::mod_add;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(mod_add.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -391,24 +414,28 @@ impl Crud for AdminPurgePerson {
   type InsertForm = AdminPurgePersonForm;
   type UpdateForm = AdminPurgePersonForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::admin_purge_person::dsl::admin_purge_person;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     admin_purge_person.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
     use crate::schema::admin_purge_person::dsl::admin_purge_person;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(admin_purge_person)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
     use crate::schema::admin_purge_person::dsl::admin_purge_person;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(admin_purge_person.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -421,27 +448,31 @@ impl Crud for AdminPurgeCommunity {
   type InsertForm = AdminPurgeCommunityForm;
   type UpdateForm = AdminPurgeCommunityForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::admin_purge_community::dsl::admin_purge_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     admin_purge_community
       .find(from_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
     use crate::schema::admin_purge_community::dsl::admin_purge_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(admin_purge_community)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
     use crate::schema::admin_purge_community::dsl::admin_purge_community;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(admin_purge_community.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -454,24 +485,28 @@ impl Crud for AdminPurgePost {
   type InsertForm = AdminPurgePostForm;
   type UpdateForm = AdminPurgePostForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::admin_purge_post::dsl::admin_purge_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     admin_purge_post.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
     use crate::schema::admin_purge_post::dsl::admin_purge_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(admin_purge_post)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
     use crate::schema::admin_purge_post::dsl::admin_purge_post;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(admin_purge_post.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -484,24 +519,28 @@ impl Crud for AdminPurgeComment {
   type InsertForm = AdminPurgeCommentForm;
   type UpdateForm = AdminPurgeCommentForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, from_id: i32) -> Result<Self, Error> {
+  async fn read(pool: DbPoolRef<'_>, from_id: i32) -> Result<Self, Error> {
     use crate::schema::admin_purge_comment::dsl::admin_purge_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     admin_purge_comment.find(from_id).first::<Self>(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
     use crate::schema::admin_purge_comment::dsl::admin_purge_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(admin_purge_comment)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn update(pool: &DbPool, from_id: i32, form: &Self::InsertForm) -> Result<Self, Error> {
+  async fn update(
+    pool: DbPoolRef<'_>,
+    from_id: i32,
+    form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
     use crate::schema::admin_purge_comment::dsl::admin_purge_comment;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(admin_purge_comment.find(from_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -547,7 +586,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/password_reset_request.rs b/crates/db_schema/src/impls/password_reset_request.rs
index 85ad4cf01..85eb6027f 100644
--- a/crates/db_schema/src/impls/password_reset_request.rs
+++ b/crates/db_schema/src/impls/password_reset_request.rs
@@ -8,7 +8,7 @@ use crate::{
   },
   source::password_reset_request::{PasswordResetRequest, PasswordResetRequestForm},
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   dsl::{insert_into, now, IntervalDsl},
@@ -16,7 +16,6 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use sha2::{Digest, Sha256};
 
 #[async_trait]
@@ -24,26 +23,26 @@ impl Crud for PasswordResetRequest {
   type InsertForm = PasswordResetRequestForm;
   type UpdateForm = PasswordResetRequestForm;
   type IdType = i32;
-  async fn read(pool: &DbPool, password_reset_request_id: i32) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, password_reset_request_id: i32) -> Result<Self, Error> {
+    let conn = pool;
     password_reset_request
       .find(password_reset_request_id)
       .first::<Self>(conn)
       .await
   }
-  async fn create(pool: &DbPool, form: &PasswordResetRequestForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &PasswordResetRequestForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(password_reset_request)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     password_reset_request_id: i32,
     form: &PasswordResetRequestForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(password_reset_request.find(password_reset_request_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -53,7 +52,7 @@ impl Crud for PasswordResetRequest {
 
 impl PasswordResetRequest {
   pub async fn create_token(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_local_user_id: LocalUserId,
     token: &str,
   ) -> Result<PasswordResetRequest, Error> {
@@ -68,8 +67,11 @@ impl PasswordResetRequest {
 
     Self::create(pool, &form).await
   }
-  pub async fn read_from_token(pool: &DbPool, token: &str) -> Result<PasswordResetRequest, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_token(
+    pool: DbPoolRef<'_>,
+    token: &str,
+  ) -> Result<PasswordResetRequest, Error> {
+    let conn = pool;
     let mut hasher = Sha256::new();
     hasher.update(token);
     let token_hash: String = bytes_to_hex(hasher.finalize().to_vec());
@@ -81,10 +83,10 @@ impl PasswordResetRequest {
   }
 
   pub async fn get_recent_password_resets_count(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     user_id: LocalUserId,
   ) -> Result<i64, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     password_reset_request
       .filter(local_user_id.eq(user_id))
       .filter(published.gt(now - 1.days()))
@@ -119,7 +121,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/person.rs b/crates/db_schema/src/impls/person.rs
index 5c23f8071..d51f0950f 100644
--- a/crates/db_schema/src/impls/person.rs
+++ b/crates/db_schema/src/impls/person.rs
@@ -9,43 +9,42 @@ use crate::{
     PersonUpdateForm,
   },
   traits::{ApubActor, Crud, Followable},
-  utils::{functions::lower, get_conn, naive_now, DbPool},
+  utils::{functions::lower, naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, JoinOnDsl, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for Person {
   type InsertForm = PersonInsertForm;
   type UpdateForm = PersonUpdateForm;
   type IdType = PersonId;
-  async fn read(pool: &DbPool, person_id: PersonId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Self, Error> {
+    let conn = pool;
     person::table
       .filter(person::deleted.eq(false))
       .find(person_id)
       .first::<Self>(conn)
       .await
   }
-  async fn delete(pool: &DbPool, person_id: PersonId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(person::table.find(person_id))
       .execute(conn)
       .await
   }
-  async fn create(pool: &DbPool, form: &PersonInsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &PersonInsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(person::table)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_id: PersonId,
     form: &PersonUpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(person::table.find(person_id))
       .set(form)
       .get_result::<Self>(conn)
@@ -57,8 +56,8 @@ impl Person {
   /// Update or insert the person.
   ///
   /// This is necessary for federation, because Activitypub doesnt distinguish between these actions.
-  pub async fn upsert(pool: &DbPool, form: &PersonInsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn upsert(pool: DbPoolRef<'_>, form: &PersonInsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(person::table)
       .values(form)
       .on_conflict(person::actor_id)
@@ -67,8 +66,8 @@ impl Person {
       .get_result::<Self>(conn)
       .await
   }
-  pub async fn delete_account(pool: &DbPool, person_id: PersonId) -> Result<Person, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn delete_account(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Person, Error> {
+    let conn = pool;
 
     // Set the local user info to none
     diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
@@ -104,8 +103,11 @@ pub fn is_banned(banned_: bool, expires: Option<chrono::NaiveDateTime>) -> bool
 
 #[async_trait]
 impl ApubActor for Person {
-  async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Option<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: &DbUrl,
+  ) -> Result<Option<Self>, Error> {
+    let conn = pool;
     Ok(
       person::table
         .filter(person::deleted.eq(false))
@@ -118,11 +120,11 @@ impl ApubActor for Person {
   }
 
   async fn read_from_name(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_name: &str,
     include_deleted: bool,
   ) -> Result<Person, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let mut q = person::table
       .into_boxed()
       .filter(person::local.eq(true))
@@ -134,11 +136,11 @@ impl ApubActor for Person {
   }
 
   async fn read_from_name_and_domain(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_name: &str,
     for_domain: &str,
   ) -> Result<Person, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     person::table
       .inner_join(instance::table)
@@ -153,9 +155,9 @@ impl ApubActor for Person {
 #[async_trait]
 impl Followable for PersonFollower {
   type Form = PersonFollowerForm;
-  async fn follow(pool: &DbPool, form: &PersonFollowerForm) -> Result<Self, Error> {
+  async fn follow(pool: DbPoolRef<'_>, form: &PersonFollowerForm) -> Result<Self, Error> {
     use crate::schema::person_follower::dsl::{follower_id, person_follower, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(person_follower)
       .values(form)
       .on_conflict((follower_id, person_id))
@@ -164,12 +166,12 @@ impl Followable for PersonFollower {
       .get_result::<Self>(conn)
       .await
   }
-  async fn follow_accepted(_: &DbPool, _: CommunityId, _: PersonId) -> Result<Self, Error> {
+  async fn follow_accepted(_: DbPoolRef<'_>, _: CommunityId, _: PersonId) -> Result<Self, Error> {
     unimplemented!()
   }
-  async fn unfollow(pool: &DbPool, form: &PersonFollowerForm) -> Result<usize, Error> {
+  async fn unfollow(pool: DbPoolRef<'_>, form: &PersonFollowerForm) -> Result<usize, Error> {
     use crate::schema::person_follower::dsl::{follower_id, person_follower, person_id};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       person_follower
         .filter(follower_id.eq(&form.follower_id))
@@ -182,10 +184,10 @@ impl Followable for PersonFollower {
 
 impl PersonFollower {
   pub async fn list_followers(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_person_id: PersonId,
   ) -> Result<Vec<Person>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     person_follower::table
       .inner_join(person::table.on(person_follower::follower_id.eq(person::id)))
       .filter(person_follower::person_id.eq(for_person_id))
@@ -210,7 +212,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
@@ -270,7 +272,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn follow() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
       .unwrap();
diff --git a/crates/db_schema/src/impls/person_block.rs b/crates/db_schema/src/impls/person_block.rs
index 9cd275563..b14845cc0 100644
--- a/crates/db_schema/src/impls/person_block.rs
+++ b/crates/db_schema/src/impls/person_block.rs
@@ -3,18 +3,17 @@ use crate::{
   schema::person_block::dsl::{person_block, person_id, target_id},
   source::person_block::{PersonBlock, PersonBlockForm},
   traits::Blockable,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 impl PersonBlock {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_person_id: PersonId,
     for_recipient_id: PersonId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     person_block
       .filter(person_id.eq(for_person_id))
       .filter(target_id.eq(for_recipient_id))
@@ -26,8 +25,8 @@ impl PersonBlock {
 #[async_trait]
 impl Blockable for PersonBlock {
   type Form = PersonBlockForm;
-  async fn block(pool: &DbPool, person_block_form: &PersonBlockForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn block(pool: DbPoolRef<'_>, person_block_form: &PersonBlockForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(person_block)
       .values(person_block_form)
       .on_conflict((person_id, target_id))
@@ -36,8 +35,8 @@ impl Blockable for PersonBlock {
       .get_result::<Self>(conn)
       .await
   }
-  async fn unblock(pool: &DbPool, person_block_form: &Self::Form) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn unblock(pool: DbPoolRef<'_>, person_block_form: &Self::Form) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(
       person_block
         .filter(person_id.eq(person_block_form.person_id))
diff --git a/crates/db_schema/src/impls/person_mention.rs b/crates/db_schema/src/impls/person_mention.rs
index 559340e78..8c23fca5c 100644
--- a/crates/db_schema/src/impls/person_mention.rs
+++ b/crates/db_schema/src/impls/person_mention.rs
@@ -3,26 +3,28 @@ use crate::{
   schema::person_mention::dsl::{comment_id, person_mention, read, recipient_id},
   source::person_mention::{PersonMention, PersonMentionInsertForm, PersonMentionUpdateForm},
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for PersonMention {
   type InsertForm = PersonMentionInsertForm;
   type UpdateForm = PersonMentionUpdateForm;
   type IdType = PersonMentionId;
-  async fn read(pool: &DbPool, person_mention_id: PersonMentionId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, person_mention_id: PersonMentionId) -> Result<Self, Error> {
+    let conn = pool;
     person_mention
       .find(person_mention_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, person_mention_form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(
+    pool: DbPoolRef<'_>,
+    person_mention_form: &Self::InsertForm,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     // since the return here isnt utilized, we dont need to do an update
     // but get_result doesnt return the existing row here
     insert_into(person_mention)
@@ -35,11 +37,11 @@ impl Crud for PersonMention {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_mention_id: PersonMentionId,
     person_mention_form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(person_mention.find(person_mention_id))
       .set(person_mention_form)
       .get_result::<Self>(conn)
@@ -49,10 +51,10 @@ impl Crud for PersonMention {
 
 impl PersonMention {
   pub async fn mark_all_as_read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_recipient_id: PersonId,
   ) -> Result<Vec<PersonMention>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(
       person_mention
         .filter(recipient_id.eq(for_recipient_id))
@@ -64,11 +66,11 @@ impl PersonMention {
   }
 
   pub async fn read_by_comment_and_person(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_comment_id: CommentId,
     for_recipient_id: PersonId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     person_mention
       .filter(comment_id.eq(for_comment_id))
       .filter(recipient_id.eq(for_recipient_id))
@@ -96,7 +98,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/post.rs b/crates/db_schema/src/impls/post.rs
index 6a4d53d3a..c33a8c16d 100644
--- a/crates/db_schema/src/impls/post.rs
+++ b/crates/db_schema/src/impls/post.rs
@@ -27,29 +27,28 @@ use crate::{
     PostUpdateForm,
   },
   traits::{Crud, Likeable, Readable, Saveable},
-  utils::{get_conn, naive_now, DbPool, DELETED_REPLACEMENT_TEXT, FETCH_LIMIT_MAX},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl, DELETED_REPLACEMENT_TEXT, FETCH_LIMIT_MAX},
 };
 use ::url::Url;
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl, TextExpressionMethods};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for Post {
   type InsertForm = PostInsertForm;
   type UpdateForm = PostUpdateForm;
   type IdType = PostId;
-  async fn read(pool: &DbPool, post_id: PostId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, post_id: PostId) -> Result<Self, Error> {
+    let conn = pool;
     post.find(post_id).first::<Self>(conn).await
   }
 
-  async fn delete(pool: &DbPool, post_id: PostId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, post_id: PostId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(post.find(post_id)).execute(conn).await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(post)
       .values(form)
       .on_conflict(ap_id)
@@ -60,11 +59,11 @@ impl Crud for Post {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     post_id: PostId,
     new_post: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(post.find(post_id))
       .set(new_post)
       .get_result::<Self>(conn)
@@ -74,10 +73,10 @@ impl Crud for Post {
 
 impl Post {
   pub async fn list_for_community(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     the_community_id: CommunityId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     post
       .filter(community_id.eq(the_community_id))
       .filter(deleted.eq(false))
@@ -90,10 +89,10 @@ impl Post {
   }
 
   pub async fn list_featured_for_community(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     the_community_id: CommunityId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     post
       .filter(community_id.eq(the_community_id))
       .filter(deleted.eq(false))
@@ -106,10 +105,10 @@ impl Post {
   }
 
   pub async fn permadelete_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     diesel::update(post.filter(creator_id.eq(for_creator_id)))
       .set((
@@ -124,12 +123,12 @@ impl Post {
   }
 
   pub async fn update_removed_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
     for_community_id: Option<CommunityId>,
     new_removed: bool,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     let mut update = diesel::update(post).into_boxed();
     update = update.filter(creator_id.eq(for_creator_id));
@@ -148,8 +147,11 @@ impl Post {
     person_id == post_creator_id
   }
 
-  pub async fn read_from_apub_id(pool: &DbPool, object_id: Url) -> Result<Option<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: Url,
+  ) -> Result<Option<Self>, Error> {
+    let conn = pool;
     let object_id: DbUrl = object_id.into();
     Ok(
       post
@@ -162,10 +164,10 @@ impl Post {
   }
 
   pub async fn fetch_pictrs_posts_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let pictrs_search = "%pictrs/image%";
 
     post
@@ -177,10 +179,10 @@ impl Post {
 
   /// Sets the url and thumbnails fields to None
   pub async fn remove_pictrs_post_images_and_thumbnails_for_creator(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_creator_id: PersonId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let pictrs_search = "%pictrs/image%";
 
     diesel::update(
@@ -197,10 +199,10 @@ impl Post {
   }
 
   pub async fn fetch_pictrs_posts_for_community(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_community_id: CommunityId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let pictrs_search = "%pictrs/image%";
     post
       .filter(community_id.eq(for_community_id))
@@ -211,10 +213,10 @@ impl Post {
 
   /// Sets the url and thumbnails fields to None
   pub async fn remove_pictrs_post_images_and_thumbnails_for_community(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_community_id: CommunityId,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let pictrs_search = "%pictrs/image%";
 
     diesel::update(
@@ -235,9 +237,9 @@ impl Post {
 impl Likeable for PostLike {
   type Form = PostLikeForm;
   type IdType = PostId;
-  async fn like(pool: &DbPool, post_like_form: &PostLikeForm) -> Result<Self, Error> {
+  async fn like(pool: DbPoolRef<'_>, post_like_form: &PostLikeForm) -> Result<Self, Error> {
     use crate::schema::post_like::dsl::{person_id, post_id, post_like};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(post_like)
       .values(post_like_form)
       .on_conflict((post_id, person_id))
@@ -246,9 +248,13 @@ impl Likeable for PostLike {
       .get_result::<Self>(conn)
       .await
   }
-  async fn remove(pool: &DbPool, person_id: PersonId, post_id: PostId) -> Result<usize, Error> {
+  async fn remove(
+    pool: DbPoolRef<'_>,
+    person_id: PersonId,
+    post_id: PostId,
+  ) -> Result<usize, Error> {
     use crate::schema::post_like::dsl;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       dsl::post_like
         .filter(dsl::post_id.eq(post_id))
@@ -262,9 +268,9 @@ impl Likeable for PostLike {
 #[async_trait]
 impl Saveable for PostSaved {
   type Form = PostSavedForm;
-  async fn save(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
+  async fn save(pool: DbPoolRef<'_>, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(post_saved)
       .values(post_saved_form)
       .on_conflict((post_id, person_id))
@@ -273,9 +279,9 @@ impl Saveable for PostSaved {
       .get_result::<Self>(conn)
       .await
   }
-  async fn unsave(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
+  async fn unsave(pool: DbPoolRef<'_>, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       post_saved
         .filter(post_id.eq(post_saved_form.post_id))
@@ -289,9 +295,9 @@ impl Saveable for PostSaved {
 #[async_trait]
 impl Readable for PostRead {
   type Form = PostReadForm;
-  async fn mark_as_read(pool: &DbPool, post_read_form: &PostReadForm) -> Result<Self, Error> {
+  async fn mark_as_read(pool: DbPoolRef<'_>, post_read_form: &PostReadForm) -> Result<Self, Error> {
     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     insert_into(post_read)
       .values(post_read_form)
       .on_conflict((post_id, person_id))
@@ -301,9 +307,12 @@ impl Readable for PostRead {
       .await
   }
 
-  async fn mark_as_unread(pool: &DbPool, post_read_form: &PostReadForm) -> Result<usize, Error> {
+  async fn mark_as_unread(
+    pool: DbPoolRef<'_>,
+    post_read_form: &PostReadForm,
+  ) -> Result<usize, Error> {
     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::delete(
       post_read
         .filter(post_id.eq(post_read_form.post_id))
@@ -341,7 +350,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/post_report.rs b/crates/db_schema/src/impls/post_report.rs
index ece7d0901..1398650ff 100644
--- a/crates/db_schema/src/impls/post_report.rs
+++ b/crates/db_schema/src/impls/post_report.rs
@@ -3,7 +3,7 @@ use crate::{
   schema::post_report::dsl::{post_report, resolved, resolver_id, updated},
   source::post_report::{PostReport, PostReportForm},
   traits::Reportable,
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   dsl::{insert_into, update},
@@ -11,15 +11,14 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Reportable for PostReport {
   type Form = PostReportForm;
   type IdType = PostReportId;
 
-  async fn report(pool: &DbPool, post_report_form: &PostReportForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn report(pool: DbPoolRef<'_>, post_report_form: &PostReportForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(post_report)
       .values(post_report_form)
       .get_result::<Self>(conn)
@@ -27,11 +26,11 @@ impl Reportable for PostReport {
   }
 
   async fn resolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(post_report.find(report_id))
       .set((
         resolved.eq(true),
@@ -43,11 +42,11 @@ impl Reportable for PostReport {
   }
 
   async fn unresolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(post_report.find(report_id))
       .set((
         resolved.eq(false),
diff --git a/crates/db_schema/src/impls/private_message.rs b/crates/db_schema/src/impls/private_message.rs
index cf6782270..af744f7d1 100644
--- a/crates/db_schema/src/impls/private_message.rs
+++ b/crates/db_schema/src/impls/private_message.rs
@@ -3,10 +3,9 @@ use crate::{
   schema::private_message::dsl::{ap_id, private_message, read, recipient_id},
   source::private_message::{PrivateMessage, PrivateMessageInsertForm, PrivateMessageUpdateForm},
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_utils::error::LemmyError;
 use url::Url;
 
@@ -15,16 +14,16 @@ impl Crud for PrivateMessage {
   type InsertForm = PrivateMessageInsertForm;
   type UpdateForm = PrivateMessageUpdateForm;
   type IdType = PrivateMessageId;
-  async fn read(pool: &DbPool, private_message_id: PrivateMessageId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, private_message_id: PrivateMessageId) -> Result<Self, Error> {
+    let conn = pool;
     private_message
       .find(private_message_id)
       .first::<Self>(conn)
       .await
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(private_message)
       .values(form)
       .on_conflict(ap_id)
@@ -35,18 +34,18 @@ impl Crud for PrivateMessage {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     private_message_id: PrivateMessageId,
     form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(private_message.find(private_message_id))
       .set(form)
       .get_result::<Self>(conn)
       .await
   }
-  async fn delete(pool: &DbPool, pm_id: Self::IdType) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, pm_id: Self::IdType) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(private_message.find(pm_id))
       .execute(conn)
       .await
@@ -55,10 +54,10 @@ impl Crud for PrivateMessage {
 
 impl PrivateMessage {
   pub async fn mark_all_as_read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_recipient_id: PersonId,
   ) -> Result<Vec<PrivateMessage>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(
       private_message
         .filter(recipient_id.eq(for_recipient_id))
@@ -70,10 +69,10 @@ impl PrivateMessage {
   }
 
   pub async fn read_from_apub_id(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     object_id: Url,
   ) -> Result<Option<Self>, LemmyError> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let object_id: DbUrl = object_id.into();
     Ok(
       private_message
@@ -102,7 +101,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut crate::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_schema/src/impls/private_message_report.rs b/crates/db_schema/src/impls/private_message_report.rs
index 5f2498c28..e1bef354d 100644
--- a/crates/db_schema/src/impls/private_message_report.rs
+++ b/crates/db_schema/src/impls/private_message_report.rs
@@ -3,7 +3,7 @@ use crate::{
   schema::private_message_report::dsl::{private_message_report, resolved, resolver_id, updated},
   source::private_message_report::{PrivateMessageReport, PrivateMessageReportForm},
   traits::Reportable,
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{
   dsl::{insert_into, update},
@@ -11,15 +11,17 @@ use diesel::{
   ExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Reportable for PrivateMessageReport {
   type Form = PrivateMessageReportForm;
   type IdType = PrivateMessageReportId;
 
-  async fn report(pool: &DbPool, pm_report_form: &PrivateMessageReportForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn report(
+    pool: DbPoolRef<'_>,
+    pm_report_form: &PrivateMessageReportForm,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(private_message_report)
       .values(pm_report_form)
       .get_result::<Self>(conn)
@@ -27,11 +29,11 @@ impl Reportable for PrivateMessageReport {
   }
 
   async fn resolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(private_message_report.find(report_id))
       .set((
         resolved.eq(true),
@@ -43,11 +45,11 @@ impl Reportable for PrivateMessageReport {
   }
 
   async fn unresolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     by_resolver_id: PersonId,
   ) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     update(private_message_report.find(report_id))
       .set((
         resolved.eq(false),
diff --git a/crates/db_schema/src/impls/registration_application.rs b/crates/db_schema/src/impls/registration_application.rs
index 208b01d01..f3d8e7ea0 100644
--- a/crates/db_schema/src/impls/registration_application.rs
+++ b/crates/db_schema/src/impls/registration_application.rs
@@ -7,10 +7,9 @@ use crate::{
     RegistrationApplicationUpdateForm,
   },
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 
 #[async_trait]
 impl Crud for RegistrationApplication {
@@ -18,33 +17,33 @@ impl Crud for RegistrationApplication {
   type UpdateForm = RegistrationApplicationUpdateForm;
   type IdType = i32;
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     insert_into(registration_application)
       .values(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn read(pool: &DbPool, id_: Self::IdType) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read(pool: DbPoolRef<'_>, id_: Self::IdType) -> Result<Self, Error> {
+    let conn = pool;
     registration_application.find(id_).first::<Self>(conn).await
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     id_: Self::IdType,
     form: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(registration_application.find(id_))
       .set(form)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn delete(pool: &DbPool, id_: Self::IdType) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, id_: Self::IdType) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(registration_application.find(id_))
       .execute(conn)
       .await
@@ -53,10 +52,10 @@ impl Crud for RegistrationApplication {
 
 impl RegistrationApplication {
   pub async fn find_by_local_user_id(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     local_user_id_: LocalUserId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     registration_application
       .filter(local_user_id.eq(local_user_id_))
       .first::<Self>(conn)
diff --git a/crates/db_schema/src/impls/secret.rs b/crates/db_schema/src/impls/secret.rs
index 4e0d9c1bd..6b62c9c3e 100644
--- a/crates/db_schema/src/impls/secret.rs
+++ b/crates/db_schema/src/impls/secret.rs
@@ -1,20 +1,19 @@
 use crate::{
   schema::secret::dsl::secret,
   source::secret::Secret,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::result::Error;
-use diesel_async::RunQueryDsl;
 
 impl Secret {
   /// Initialize the Secrets from the DB.
   /// Warning: You should only call this once.
-  pub async fn init(pool: &DbPool) -> Result<Secret, Error> {
+  pub async fn init(pool: DbPoolRef<'_>) -> Result<Secret, Error> {
     Self::read_secrets(pool).await
   }
 
-  async fn read_secrets(pool: &DbPool) -> Result<Secret, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn read_secrets(pool: DbPoolRef<'_>) -> Result<Secret, Error> {
+    let conn = pool;
     secret.first::<Secret>(conn).await
   }
 }
diff --git a/crates/db_schema/src/impls/site.rs b/crates/db_schema/src/impls/site.rs
index 3363edc93..0e97aa756 100644
--- a/crates/db_schema/src/impls/site.rs
+++ b/crates/db_schema/src/impls/site.rs
@@ -6,10 +6,9 @@ use crate::{
     site::{Site, SiteInsertForm, SiteUpdateForm},
   },
   traits::Crud,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use url::Url;
 
 #[async_trait]
@@ -19,12 +18,12 @@ impl Crud for Site {
   type IdType = SiteId;
 
   /// Use SiteView::read_local, or Site::read_from_apub_id instead
-  async fn read(_pool: &DbPool, _site_id: SiteId) -> Result<Self, Error> {
+  async fn read(_pool: DbPoolRef<'_>, _site_id: SiteId) -> Result<Self, Error> {
     unimplemented!()
   }
 
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
+    let conn = pool;
     let is_new_site = match &form.actor_id {
       Some(id_) => Site::read_from_apub_id(pool, id_).await?.is_none(),
       None => true,
@@ -48,26 +47,29 @@ impl Crud for Site {
   }
 
   async fn update(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     site_id: SiteId,
     new_site: &Self::UpdateForm,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     diesel::update(site.find(site_id))
       .set(new_site)
       .get_result::<Self>(conn)
       .await
   }
 
-  async fn delete(pool: &DbPool, site_id: SiteId) -> Result<usize, Error> {
-    let conn = &mut get_conn(pool).await?;
+  async fn delete(pool: DbPoolRef<'_>, site_id: SiteId) -> Result<usize, Error> {
+    let conn = pool;
     diesel::delete(site.find(site_id)).execute(conn).await
   }
 }
 
 impl Site {
-  pub async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Option<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_apub_id(
+    pool: DbPoolRef<'_>,
+    object_id: &DbUrl,
+  ) -> Result<Option<Self>, Error> {
+    let conn = pool;
     Ok(
       site
         .filter(actor_id.eq(object_id))
@@ -79,8 +81,8 @@ impl Site {
   }
 
   // TODO this needs fixed
-  pub async fn read_remote_sites(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_remote_sites(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     site.order_by(id).offset(1).get_results::<Self>(conn).await
   }
 
diff --git a/crates/db_schema/src/impls/tagline.rs b/crates/db_schema/src/impls/tagline.rs
index ec985a3c8..54983a342 100644
--- a/crates/db_schema/src/impls/tagline.rs
+++ b/crates/db_schema/src/impls/tagline.rs
@@ -2,18 +2,18 @@ use crate::{
   newtypes::LocalSiteId,
   schema::tagline::dsl::{local_site_id, tagline},
   source::tagline::{Tagline, TaglineForm},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use diesel::{insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use diesel_async::AsyncPgConnection;
 
 impl Tagline {
   pub async fn replace(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     for_local_site_id: LocalSiteId,
     list_content: Option<Vec<String>>,
   ) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     if let Some(list) = list_content {
       conn
         .build_transaction()
@@ -46,7 +46,7 @@ impl Tagline {
   }
 
   async fn get_all_conn(
-    conn: &mut AsyncPgConnection,
+    conn: DbPoolRef<'_>,
     for_local_site_id: LocalSiteId,
   ) -> Result<Vec<Self>, Error> {
     tagline
@@ -54,8 +54,11 @@ impl Tagline {
       .get_results::<Self>(conn)
       .await
   }
-  pub async fn get_all(pool: &DbPool, for_local_site_id: LocalSiteId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn get_all(
+    pool: DbPoolRef<'_>,
+    for_local_site_id: LocalSiteId,
+  ) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     Self::get_all_conn(conn, for_local_site_id).await
   }
 }
diff --git a/crates/db_schema/src/traits.rs b/crates/db_schema/src/traits.rs
index 12b92b3d9..d6ff44820 100644
--- a/crates/db_schema/src/traits.rs
+++ b/crates/db_schema/src/traits.rs
@@ -1,6 +1,7 @@
 use crate::{
   newtypes::{CommunityId, DbUrl, PersonId},
   utils::DbPool,
+  DbPoolRef,
 };
 use diesel::result::Error;
 
@@ -9,17 +10,21 @@ pub trait Crud {
   type InsertForm;
   type UpdateForm;
   type IdType;
-  async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error>
+  async fn create(pool: DbPoolRef<'_>, form: &Self::InsertForm) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn read(pool: &DbPool, id: Self::IdType) -> Result<Self, Error>
+  async fn read(pool: DbPoolRef<'_>, id: Self::IdType) -> Result<Self, Error>
   where
     Self: Sized;
   /// when you want to null out a column, you have to send Some(None)), since sending None means you just don't want to update that column.
-  async fn update(pool: &DbPool, id: Self::IdType, form: &Self::UpdateForm) -> Result<Self, Error>
+  async fn update(
+    pool: DbPoolRef<'_>,
+    id: Self::IdType,
+    form: &Self::UpdateForm,
+  ) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn delete(_pool: &DbPool, _id: Self::IdType) -> Result<usize, Error>
+  async fn delete(_pool: DbPoolRef<'_>, _id: Self::IdType) -> Result<usize, Error>
   where
     Self: Sized,
     Self::IdType: Send,
@@ -31,17 +36,17 @@ pub trait Crud {
 #[async_trait]
 pub trait Followable {
   type Form;
-  async fn follow(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn follow(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
   async fn follow_accepted(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_id: CommunityId,
     person_id: PersonId,
   ) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn unfollow(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn unfollow(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -49,10 +54,10 @@ pub trait Followable {
 #[async_trait]
 pub trait Joinable {
   type Form;
-  async fn join(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn join(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn leave(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn leave(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -61,11 +66,11 @@ pub trait Joinable {
 pub trait Likeable {
   type Form;
   type IdType;
-  async fn like(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn like(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
   async fn remove(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_id: PersonId,
     item_id: Self::IdType,
   ) -> Result<usize, Error>
@@ -76,10 +81,10 @@ pub trait Likeable {
 #[async_trait]
 pub trait Bannable {
   type Form;
-  async fn ban(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn ban(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn unban(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn unban(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -87,10 +92,10 @@ pub trait Bannable {
 #[async_trait]
 pub trait Saveable {
   type Form;
-  async fn save(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn save(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn unsave(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn unsave(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -98,10 +103,10 @@ pub trait Saveable {
 #[async_trait]
 pub trait Blockable {
   type Form;
-  async fn block(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn block(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn unblock(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn unblock(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -109,10 +114,10 @@ pub trait Blockable {
 #[async_trait]
 pub trait Readable {
   type Form;
-  async fn mark_as_read(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn mark_as_read(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
-  async fn mark_as_unread(pool: &DbPool, form: &Self::Form) -> Result<usize, Error>
+  async fn mark_as_unread(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<usize, Error>
   where
     Self: Sized;
 }
@@ -121,18 +126,18 @@ pub trait Readable {
 pub trait Reportable {
   type Form;
   type IdType;
-  async fn report(pool: &DbPool, form: &Self::Form) -> Result<Self, Error>
+  async fn report(pool: DbPoolRef<'_>, form: &Self::Form) -> Result<Self, Error>
   where
     Self: Sized;
   async fn resolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     resolver_id: PersonId,
   ) -> Result<usize, Error>
   where
     Self: Sized;
   async fn unresolve(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: Self::IdType,
     resolver_id: PersonId,
   ) -> Result<usize, Error>
@@ -149,20 +154,20 @@ pub trait JoinView {
 
 #[async_trait]
 pub trait ApubActor {
-  async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Option<Self>, Error>
+  async fn read_from_apub_id(pool: DbPoolRef<'_>, object_id: &DbUrl) -> Result<Option<Self>, Error>
   where
     Self: Sized;
   /// - actor_name is the name of the community or user to read.
   /// - include_deleted, if true, will return communities or users that were deleted/removed
   async fn read_from_name(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     actor_name: &str,
     include_deleted: bool,
   ) -> Result<Self, Error>
   where
     Self: Sized;
   async fn read_from_name_and_domain(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     actor_name: &str,
     protocol_domain: &str,
   ) -> Result<Self, Error>
diff --git a/crates/db_schema/src/utils.rs b/crates/db_schema/src/utils.rs
index 1dc2f9afa..5069111b1 100644
--- a/crates/db_schema/src/utils.rs
+++ b/crates/db_schema/src/utils.rs
@@ -6,23 +6,29 @@ use crate::{
   SortType,
 };
 use activitypub_federation::{fetch::object_id::ObjectId, traits::Object};
+use async_trait::async_trait;
 use chrono::NaiveDateTime;
 use deadpool::Runtime;
 use diesel::{
   backend::Backend,
   deserialize::FromSql,
+  helper_types::Limit,
   pg::Pg,
+  query_dsl::methods::LimitDsl,
   result::{ConnectionError, ConnectionResult, Error as DieselError, Error::QueryBuilderError},
   serialize::{Output, ToSql},
   sql_types::Text,
   PgConnection,
+  RunQueryDsl as DieselRun,
 };
 use diesel_async::{
+  methods::{ExecuteDsl, LoadQuery},
   pg::AsyncPgConnection,
   pooled_connection::{
     deadpool::{Object as PooledConnection, Pool},
     AsyncDieselConnectionManager,
   },
+  scoped_futures::ScopedBoxFuture,
 };
 use diesel_migrations::EmbeddedMigrations;
 use futures_util::{future::BoxFuture, FutureExt};
@@ -46,12 +52,98 @@ const FETCH_LIMIT_DEFAULT: i64 = 10;
 pub const FETCH_LIMIT_MAX: i64 = 50;
 const POOL_TIMEOUT: Option<Duration> = Some(Duration::from_secs(5));
 
-pub type DbPool = Pool<AsyncPgConnection>;
+pub type OwnedDbPool = Pool<AsyncPgConnection>;
 
-pub async fn get_conn(pool: &DbPool) -> Result<PooledConnection<AsyncPgConnection>, DieselError> {
-  pool.get().await.map_err(|e| QueryBuilderError(e.into()))
+pub type DbPoolRef<'a> = &'a mut DbPool<'a>;
+
+pub enum DbPool<'pool> {
+  Conn(&'pool mut AsyncPgConnection),
+  Pool(&'pool Pool<AsyncPgConnection>),
 }
 
+impl<'pool> DbPool<'pool> {
+  pub async fn with_conn<'a, R, E, F>(&mut self, callback: F) -> Result<R, E>
+  where
+    F: for<'r> FnOnce(&'r mut AsyncPgConnection) -> ScopedBoxFuture<'a, 'r, Result<R, E>>
+      + Send
+      + 'a,
+    E: From<DieselError>,
+    R: Send + 'a,
+  {
+    match self {
+      DbPool::Conn(conn) => callback(conn).await,
+      DbPool::Pool(pool) => {
+        callback(pool.get().await.map_err(|e| QueryBuilderError(e.into())?)).await
+      }
+    }
+  }
+
+  pub async fn transaction<'a, R, E, F>(&mut self, callback: F) -> Result<R, E>
+  where
+    F: for<'r> FnOnce(&'r mut Self) -> ScopedBoxFuture<'a, 'r, Result<R, E>> + Send + 'a,
+    E: From<DieselError> + Send + 'a,
+    R: Send + 'a,
+  {
+    self.with_conn(|conn| conn.transaction(callback)).await
+  }
+}
+
+#[async_trait]
+pub trait RunQueryDsl<'query, 'conn>: Sized + 'query {
+  pub async fn execute(self, pool: &'conn mut DbPool) -> Result<usize, DieselError>
+  where
+    Self: ExecuteDsl<AsyncPgConnection>,
+  {
+    pool.with_conn(|conn| DieselRun::execute(self, conn)).await
+  }
+
+  pub async fn load<U>(self, pool: &'conn mut DbPool) -> Result<Vec<U>, DieselError>
+  where
+    U: Send,
+    Self: LoadQuery<'query, AsyncPgConnection, U> + 'query,
+  {
+    pool.with_conn(|conn| DieselRun::load(self, conn)).await
+  }
+
+  // todo load_stream
+
+  pub async fn get_result<U>(self, pool: &'conn mut DbPool) -> Result<U, DieselError>
+  where
+    U: Send + 'conn,
+    Self: LoadQuery<'query, AsyncPgConnection, U> + 'query,
+  {
+    pool
+      .with_conn(|conn| DieselRun::get_result(self, conn))
+      .await
+  }
+
+  pub async fn get_results<U>(self, pool: &'conn mut DbPool) -> Result<Vec<U>, DieselError>
+  where
+    U: Send,
+    Self: LoadQuery<'query, AsyncPgConnection, U> + 'query,
+  {
+    pool
+      .with_conn(|conn| DieselRun::get_results(self, conn))
+      .await
+  }
+
+  pub async fn first<U>(self, pool: &'conn mut DbPool) -> Result<U, DieselError>
+  where
+    U: Send + 'conn,
+    Self: LimitDsl,
+    Limit<Self>: LoadQuery<'query, AsyncPgConnection, U> + Send + 'query,
+  {
+    pool.with_conn(|conn| DieselRun::first(self, conn)).await
+  }
+}
+
+#[async_trait]
+impl<'query, 'conn, T: Sized + 'query> RunQueryDsl<'query, 'conn> for T {}
+
+/*pub async fn get_conn(pool: &mut DbPool) -> Result<PooledConnection<AsyncPgConnection>, DieselError> {
+  pool.get().await.map_err(|e| QueryBuilderError(e.into()))
+}*/
+
 pub fn get_database_url_from_env() -> Result<String, VarError> {
   env::var("LEMMY_DATABASE_URL")
 }
@@ -143,7 +235,9 @@ pub fn diesel_option_overwrite_to_url_create(
   }
 }
 
-async fn build_db_pool_settings_opt(settings: Option<&Settings>) -> Result<DbPool, LemmyError> {
+async fn build_db_pool_settings_opt(
+  settings: Option<&Settings>,
+) -> Result<OwnedDbPool, LemmyError> {
   let db_url = get_database_url(settings);
   let pool_size = settings.map(|s| s.database.pool_size).unwrap_or(5);
   // We only support TLS with sslmode=require currently
@@ -222,11 +316,11 @@ pub fn run_migrations(db_url: &str) {
   info!("Database migrations complete.");
 }
 
-pub async fn build_db_pool(settings: &Settings) -> Result<DbPool, LemmyError> {
+pub async fn build_db_pool(settings: &Settings) -> Result<OwnedDbPool, LemmyError> {
   build_db_pool_settings_opt(Some(settings)).await
 }
 
-pub async fn build_db_pool_for_tests() -> DbPool {
+pub async fn build_db_pool_for_tests() -> OwnedDbPool {
   build_db_pool_settings_opt(None)
     .await
     .expect("db pool missing")
diff --git a/crates/db_views/src/comment_report_view.rs b/crates/db_views/src/comment_report_view.rs
index 4a5397b32..12fd06fb8 100644
--- a/crates/db_views/src/comment_report_view.rs
+++ b/crates/db_views/src/comment_report_view.rs
@@ -8,7 +8,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::CommentAggregates,
   newtypes::{CommentReportId, CommunityId, PersonId},
@@ -31,7 +30,7 @@ use lemmy_db_schema::{
     post::Post,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 use typed_builder::TypedBuilder;
 
@@ -40,11 +39,11 @@ impl CommentReportView {
   ///
   /// * `report_id` - the report id to obtain
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: CommentReportId,
     my_person_id: PersonId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
 
@@ -96,14 +95,14 @@ impl CommentReportView {
 
   /// Returns the current unresolved post report count for the communities you mod
   pub async fn get_report_count(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     my_person_id: PersonId,
     admin: bool,
     community_id: Option<CommunityId>,
   ) -> Result<i64, Error> {
     use diesel::dsl::count;
 
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     let mut query = comment_report::table
       .inner_join(comment::table)
@@ -141,7 +140,7 @@ impl CommentReportView {
 #[builder(field_defaults(default))]
 pub struct CommentReportQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   #[builder(!default)]
   my_person_id: PersonId,
   #[builder(!default)]
@@ -292,7 +291,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_views/src/comment_view.rs b/crates/db_views/src/comment_view.rs
index f3b1f83a8..77621212d 100644
--- a/crates/db_views/src/comment_view.rs
+++ b/crates/db_views/src/comment_view.rs
@@ -8,7 +8,6 @@ use diesel::{
   PgTextExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use diesel_ltree::{nlevel, subpath, Ltree, LtreeExtensions};
 use lemmy_db_schema::{
   aggregates::structs::CommentAggregates,
@@ -36,7 +35,7 @@ use lemmy_db_schema::{
     post::Post,
   },
   traits::JoinView,
-  utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
+  utils::{fuzzy_search, limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   CommentSortType,
   ListingType,
 };
@@ -57,11 +56,11 @@ type CommentViewTuple = (
 
 impl CommentView {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     comment_id: CommentId,
     my_person_id: Option<PersonId>,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     // The left join below will return None in this case
     let person_id_join = my_person_id.unwrap_or(PersonId(-1));
@@ -160,7 +159,7 @@ impl CommentView {
 #[builder(field_defaults(default))]
 pub struct CommentQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   listing_type: Option<ListingType>,
   sort: Option<CommentSortType>,
   community_id: Option<CommunityId>,
@@ -393,6 +392,7 @@ mod tests {
     CommentView,
     Community,
     DbPool,
+    DbPoolRef,
     LocalUser,
     Person,
     PersonBlock,
@@ -431,7 +431,7 @@ mod tests {
     inserted_community: Community,
   }
 
-  async fn init_data(pool: &DbPool) -> Data {
+  async fn init_data(pool: DbPoolRef<'_>) -> Data {
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
       .unwrap();
@@ -593,7 +593,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let expected_comment_view_no_person = expected_comment_view(&data, pool).await;
@@ -650,7 +650,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_comment_tree() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let top_path = data.inserted_comment_0.path.clone();
@@ -726,7 +726,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_languages() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     // by default, user has all languages enabled and should see all comments
@@ -781,7 +781,7 @@ mod tests {
     cleanup(data, pool).await;
   }
 
-  async fn cleanup(data: Data, pool: &DbPool) {
+  async fn cleanup(data: Data, pool: DbPoolRef<'_>) {
     CommentLike::remove(pool, data.inserted_person.id, data.inserted_comment_0.id)
       .await
       .unwrap();
@@ -804,7 +804,7 @@ mod tests {
       .unwrap();
   }
 
-  async fn expected_comment_view(data: &Data, pool: &DbPool) -> CommentView {
+  async fn expected_comment_view(data: &Data, pool: DbPoolRef<'_>) -> CommentView {
     let agg = CommentAggregates::read(pool, data.inserted_comment_0.id)
       .await
       .unwrap();
diff --git a/crates/db_views/src/custom_emoji_view.rs b/crates/db_views/src/custom_emoji_view.rs
index 66d583e32..2779ee303 100644
--- a/crates/db_views/src/custom_emoji_view.rs
+++ b/crates/db_views/src/custom_emoji_view.rs
@@ -1,19 +1,18 @@
 use crate::structs::CustomEmojiView;
 use diesel::{result::Error, ExpressionMethods, JoinOnDsl, NullableExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{CustomEmojiId, LocalSiteId},
   schema::{custom_emoji, custom_emoji_keyword},
   source::{custom_emoji::CustomEmoji, custom_emoji_keyword::CustomEmojiKeyword},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 use std::collections::HashMap;
 
 type CustomEmojiTuple = (CustomEmoji, Option<CustomEmojiKeyword>);
 
 impl CustomEmojiView {
-  pub async fn get(pool: &DbPool, emoji_id: CustomEmojiId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn get(pool: DbPoolRef<'_>, emoji_id: CustomEmojiId) -> Result<Self, Error> {
+    let conn = pool;
     let emojis = custom_emoji::table
       .find(emoji_id)
       .left_join(
@@ -35,8 +34,11 @@ impl CustomEmojiView {
     }
   }
 
-  pub async fn get_all(pool: &DbPool, for_local_site_id: LocalSiteId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn get_all(
+    pool: DbPoolRef<'_>,
+    for_local_site_id: LocalSiteId,
+  ) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let emojis = custom_emoji::table
       .filter(custom_emoji::local_site_id.eq(for_local_site_id))
       .left_join(
diff --git a/crates/db_views/src/local_user_view.rs b/crates/db_views/src/local_user_view.rs
index f37986cc9..87e263c09 100644
--- a/crates/db_views/src/local_user_view.rs
+++ b/crates/db_views/src/local_user_view.rs
@@ -1,20 +1,19 @@
 use crate::structs::LocalUserView;
 use diesel::{result::Error, BoolExpressionMethods, ExpressionMethods, JoinOnDsl, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::PersonAggregates,
   newtypes::{LocalUserId, PersonId},
   schema::{local_user, person, person_aggregates},
   source::{local_user::LocalUser, person::Person},
   traits::JoinView,
-  utils::{functions::lower, get_conn, DbPool},
+  utils::{functions::lower, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type LocalUserViewTuple = (LocalUser, Person, PersonAggregates);
 
 impl LocalUserView {
-  pub async fn read(pool: &DbPool, local_user_id: LocalUserId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, local_user_id: LocalUserId) -> Result<Self, Error> {
+    let conn = pool;
 
     let (local_user, person, counts) = local_user::table
       .find(local_user_id)
@@ -34,8 +33,8 @@ impl LocalUserView {
     })
   }
 
-  pub async fn read_person(pool: &DbPool, person_id: PersonId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_person(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Self, Error> {
+    let conn = pool;
     let (local_user, person, counts) = local_user::table
       .filter(person::id.eq(person_id))
       .inner_join(person::table)
@@ -54,8 +53,8 @@ impl LocalUserView {
     })
   }
 
-  pub async fn read_from_name(pool: &DbPool, name: &str) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_from_name(pool: DbPoolRef<'_>, name: &str) -> Result<Self, Error> {
+    let conn = pool;
     let (local_user, person, counts) = local_user::table
       .filter(lower(person::name).eq(name.to_lowercase()))
       .inner_join(person::table)
@@ -74,8 +73,11 @@ impl LocalUserView {
     })
   }
 
-  pub async fn find_by_email_or_name(pool: &DbPool, name_or_email: &str) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn find_by_email_or_name(
+    pool: DbPoolRef<'_>,
+    name_or_email: &str,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     let (local_user, person, counts) = local_user::table
       .inner_join(person::table)
       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
@@ -98,8 +100,8 @@ impl LocalUserView {
     })
   }
 
-  pub async fn find_by_email(pool: &DbPool, from_email: &str) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn find_by_email(pool: DbPoolRef<'_>, from_email: &str) -> Result<Self, Error> {
+    let conn = pool;
     let (local_user, person, counts) = local_user::table
       .inner_join(person::table)
       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
@@ -118,8 +120,8 @@ impl LocalUserView {
     })
   }
 
-  pub async fn list_admins_with_emails(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list_admins_with_emails(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = local_user::table
       .filter(person::admin.eq(true))
       .filter(local_user::email.is_not_null())
diff --git a/crates/db_views/src/post_report_view.rs b/crates/db_views/src/post_report_view.rs
index 19822c795..949a153f0 100644
--- a/crates/db_views/src/post_report_view.rs
+++ b/crates/db_views/src/post_report_view.rs
@@ -7,7 +7,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::PostAggregates,
   newtypes::{CommunityId, PersonId, PostReportId},
@@ -28,7 +27,7 @@ use lemmy_db_schema::{
     post_report::PostReport,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 use typed_builder::TypedBuilder;
 
@@ -49,11 +48,11 @@ impl PostReportView {
   ///
   /// * `report_id` - the report id to obtain
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     report_id: PostReportId,
     my_person_id: PersonId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
 
     let (
@@ -121,13 +120,13 @@ impl PostReportView {
 
   /// returns the current unresolved post report count for the communities you mod
   pub async fn get_report_count(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     my_person_id: PersonId,
     admin: bool,
     community_id: Option<CommunityId>,
   ) -> Result<i64, Error> {
     use diesel::dsl::count;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let mut query = post_report::table
       .inner_join(post::table)
       .filter(post_report::resolved.eq(false))
@@ -163,7 +162,7 @@ impl PostReportView {
 #[builder(field_defaults(default))]
 pub struct PostReportQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   #[builder(!default)]
   my_person_id: PersonId,
   #[builder(!default)]
@@ -287,7 +286,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs
index d1e974d8a..5ee30c145 100644
--- a/crates/db_views/src/post_view.rs
+++ b/crates/db_views/src/post_view.rs
@@ -13,7 +13,6 @@ use diesel::{
   PgTextExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::PostAggregates,
   newtypes::{CommunityId, LocalUserId, PersonId, PostId},
@@ -40,7 +39,7 @@ use lemmy_db_schema::{
     post::{Post, PostRead, PostSaved},
   },
   traits::JoinView,
-  utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
+  utils::{fuzzy_search, limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   ListingType,
   SortType,
 };
@@ -65,12 +64,12 @@ sql_function!(fn coalesce(x: sql_types::Nullable<sql_types::BigInt>, y: sql_type
 
 impl PostView {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     post_id: PostId,
     my_person_id: Option<PersonId>,
     is_mod_or_admin: Option<bool>,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     // The left join below will return None in this case
     let person_id_join = my_person_id.unwrap_or(PersonId(-1));
@@ -197,7 +196,7 @@ impl PostView {
 #[builder(field_defaults(default))]
 pub struct PostQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   listing_type: Option<ListingType>,
   sort: Option<SortType>,
   creator_id: Option<PersonId>,
@@ -494,7 +493,7 @@ mod tests {
       post::{Post, PostInsertForm, PostLike, PostLikeForm, PostUpdateForm},
     },
     traits::{Blockable, Crud, Likeable},
-    utils::{build_db_pool_for_tests, DbPool},
+    utils::{build_db_pool_for_tests, DbPool, DbPoolRef},
     SortType,
     SubscribedType,
   };
@@ -510,7 +509,7 @@ mod tests {
     inserted_post: Post,
   }
 
-  async fn init_data(pool: &DbPool) -> Data {
+  async fn init_data(pool: DbPoolRef<'_>) -> Data {
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
       .unwrap();
@@ -607,7 +606,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listing_with_person() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let local_user_form = LocalUserUpdateForm::builder()
@@ -675,7 +674,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listing_no_person() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let read_post_listing_multiple_no_person = PostQuery::builder()
@@ -712,7 +711,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listing_block_community() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let community_block = CommunityBlockForm {
@@ -742,7 +741,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listing_like() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let post_like_form = PostLikeForm {
@@ -808,7 +807,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listing_person_language() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     let spanish_id = Language::read_id_from_code(pool, Some("es"))
@@ -889,7 +888,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn post_listings_deleted() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
     let data = init_data(pool).await;
 
     // Delete the post
@@ -930,7 +929,7 @@ mod tests {
     cleanup(data, pool).await;
   }
 
-  async fn cleanup(data: Data, pool: &DbPool) {
+  async fn cleanup(data: Data, pool: DbPoolRef<'_>) {
     let num_deleted = Post::delete(pool, data.inserted_post.id).await.unwrap();
     Community::delete(pool, data.inserted_community.id)
       .await
@@ -946,7 +945,7 @@ mod tests {
     assert_eq!(1, num_deleted);
   }
 
-  async fn expected_post_view(data: &Data, pool: &DbPool) -> PostView {
+  async fn expected_post_view(data: &Data, pool: DbPoolRef<'_>) -> PostView {
     let (inserted_person, inserted_community, inserted_post) = (
       &data.inserted_person,
       &data.inserted_community,
diff --git a/crates/db_views/src/private_message_report_view.rs b/crates/db_views/src/private_message_report_view.rs
index 2bcad6f83..fc2af2a03 100644
--- a/crates/db_views/src/private_message_report_view.rs
+++ b/crates/db_views/src/private_message_report_view.rs
@@ -1,6 +1,5 @@
 use crate::structs::PrivateMessageReportView;
 use diesel::{result::Error, ExpressionMethods, JoinOnDsl, NullableExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PrivateMessageReportId,
   schema::{person, private_message, private_message_report},
@@ -10,7 +9,7 @@ use lemmy_db_schema::{
     private_message_report::PrivateMessageReport,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 use typed_builder::TypedBuilder;
 
@@ -26,8 +25,8 @@ impl PrivateMessageReportView {
   /// returns the PrivateMessageReportView for the provided report_id
   ///
   /// * `report_id` - the report id to obtain
-  pub async fn read(pool: &DbPool, report_id: PrivateMessageReportId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, report_id: PrivateMessageReportId) -> Result<Self, Error> {
+    let conn = pool;
     let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
 
     let (private_message_report, private_message, private_message_creator, creator, resolver) =
@@ -64,9 +63,9 @@ impl PrivateMessageReportView {
   }
 
   /// Returns the current unresolved post report count for the communities you mod
-  pub async fn get_report_count(pool: &DbPool) -> Result<i64, Error> {
+  pub async fn get_report_count(pool: DbPoolRef<'_>) -> Result<i64, Error> {
     use diesel::dsl::count;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     private_message_report::table
       .inner_join(private_message::table)
@@ -82,7 +81,7 @@ impl PrivateMessageReportView {
 #[builder(field_defaults(default))]
 pub struct PrivateMessageReportQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   page: Option<i64>,
   limit: Option<i64>,
   unresolved_only: Option<bool>,
@@ -165,7 +164,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_views/src/private_message_view.rs b/crates/db_views/src/private_message_view.rs
index 76b817a96..bc8936412 100644
--- a/crates/db_views/src/private_message_view.rs
+++ b/crates/db_views/src/private_message_view.rs
@@ -8,13 +8,12 @@ use diesel::{
   JoinOnDsl,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{PersonId, PrivateMessageId},
   schema::{person, private_message},
   source::{person::Person, private_message::PrivateMessage},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 use tracing::debug;
 use typed_builder::TypedBuilder;
@@ -22,8 +21,11 @@ use typed_builder::TypedBuilder;
 type PrivateMessageViewTuple = (PrivateMessage, Person, Person);
 
 impl PrivateMessageView {
-  pub async fn read(pool: &DbPool, private_message_id: PrivateMessageId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(
+    pool: DbPoolRef<'_>,
+    private_message_id: PrivateMessageId,
+  ) -> Result<Self, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
 
     let (private_message, creator, recipient) = private_message::table
@@ -49,9 +51,12 @@ impl PrivateMessageView {
   }
 
   /// Gets the number of unread messages
-  pub async fn get_unread_messages(pool: &DbPool, my_person_id: PersonId) -> Result<i64, Error> {
+  pub async fn get_unread_messages(
+    pool: DbPoolRef<'_>,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
     use diesel::dsl::count;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     private_message::table
       .filter(private_message::read.eq(false))
       .filter(private_message::recipient_id.eq(my_person_id))
@@ -66,7 +71,7 @@ impl PrivateMessageView {
 #[builder(field_defaults(default))]
 pub struct PrivateMessageQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   #[builder(!default)]
   recipient_id: PersonId,
   unread_only: Option<bool>,
diff --git a/crates/db_views/src/registration_application_view.rs b/crates/db_views/src/registration_application_view.rs
index 9963ed466..0a013df0a 100644
--- a/crates/db_views/src/registration_application_view.rs
+++ b/crates/db_views/src/registration_application_view.rs
@@ -7,7 +7,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   schema::{local_user, person, registration_application},
   source::{
@@ -16,7 +15,7 @@ use lemmy_db_schema::{
     registration_application::RegistrationApplication,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 use typed_builder::TypedBuilder;
 
@@ -24,8 +23,8 @@ type RegistrationApplicationViewTuple =
   (RegistrationApplication, LocalUser, Person, Option<Person>);
 
 impl RegistrationApplicationView {
-  pub async fn read(pool: &DbPool, registration_application_id: i32) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, registration_application_id: i32) -> Result<Self, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
 
     let (registration_application, creator_local_user, creator, admin) =
@@ -58,8 +57,11 @@ impl RegistrationApplicationView {
   }
 
   /// Returns the current unread registration_application count
-  pub async fn get_unread_count(pool: &DbPool, verified_email_only: bool) -> Result<i64, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn get_unread_count(
+    pool: DbPoolRef<'_>,
+    verified_email_only: bool,
+  ) -> Result<i64, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
 
     let mut query = registration_application::table
@@ -87,7 +89,7 @@ impl RegistrationApplicationView {
 #[builder(field_defaults(default))]
 pub struct RegistrationApplicationQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   unread_only: Option<bool>,
   verified_email_only: Option<bool>,
   page: Option<i64>,
@@ -178,7 +180,7 @@ mod tests {
   #[tokio::test]
   #[serial]
   async fn test_crud() {
-    let pool = &build_db_pool_for_tests().await;
+    let mut pool = &mut lemmy_db_schema::utils::DbPool::Pool(&build_db_pool_for_tests().await);
 
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
diff --git a/crates/db_views/src/site_view.rs b/crates/db_views/src/site_view.rs
index a1d0231a2..7307eb28d 100644
--- a/crates/db_views/src/site_view.rs
+++ b/crates/db_views/src/site_view.rs
@@ -1,16 +1,15 @@
 use crate::structs::SiteView;
 use diesel::{result::Error, ExpressionMethods, JoinOnDsl, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::SiteAggregates,
   schema::{local_site, local_site_rate_limit, site, site_aggregates},
   source::{local_site::LocalSite, local_site_rate_limit::LocalSiteRateLimit, site::Site},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 impl SiteView {
-  pub async fn read_local(pool: &DbPool) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read_local(pool: DbPoolRef<'_>) -> Result<Self, Error> {
+    let conn = pool;
     let (mut site, local_site, local_site_rate_limit, counts) = site::table
       .inner_join(local_site::table)
       .inner_join(
diff --git a/crates/db_views_actor/src/comment_reply_view.rs b/crates/db_views_actor/src/comment_reply_view.rs
index 42c3a53e0..8faf746e1 100644
--- a/crates/db_views_actor/src/comment_reply_view.rs
+++ b/crates/db_views_actor/src/comment_reply_view.rs
@@ -7,7 +7,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::CommentAggregates,
   newtypes::{CommentReplyId, PersonId},
@@ -33,7 +32,7 @@ use lemmy_db_schema::{
     post::Post,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   CommentSortType,
 };
 use typed_builder::TypedBuilder;
@@ -55,11 +54,11 @@ type CommentReplyViewTuple = (
 
 impl CommentReplyView {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     comment_reply_id: CommentReplyId,
     my_person_id: Option<PersonId>,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
 
     // The left join below will return None in this case
@@ -155,10 +154,13 @@ impl CommentReplyView {
   }
 
   /// Gets the number of unread replies
-  pub async fn get_unread_replies(pool: &DbPool, my_person_id: PersonId) -> Result<i64, Error> {
+  pub async fn get_unread_replies(
+    pool: DbPoolRef<'_>,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
     use diesel::dsl::count;
 
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     comment_reply::table
       .inner_join(comment::table)
@@ -176,7 +178,7 @@ impl CommentReplyView {
 #[builder(field_defaults(default))]
 pub struct CommentReplyQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   my_person_id: Option<PersonId>,
   recipient_id: Option<PersonId>,
   sort: Option<CommentSortType>,
diff --git a/crates/db_views_actor/src/community_block_view.rs b/crates/db_views_actor/src/community_block_view.rs
index d87bea37f..db345f474 100644
--- a/crates/db_views_actor/src/community_block_view.rs
+++ b/crates/db_views_actor/src/community_block_view.rs
@@ -1,19 +1,18 @@
 use crate::structs::CommunityBlockView;
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, community_block, person},
   source::{community::Community, person::Person},
   traits::JoinView,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type CommunityBlockViewTuple = (Person, Community);
 
 impl CommunityBlockView {
-  pub async fn for_person(pool: &DbPool, person_id: PersonId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_person(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_block::table
       .inner_join(person::table)
       .inner_join(community::table)
diff --git a/crates/db_views_actor/src/community_follower_view.rs b/crates/db_views_actor/src/community_follower_view.rs
index ccc7ae706..3b7430d05 100644
--- a/crates/db_views_actor/src/community_follower_view.rs
+++ b/crates/db_views_actor/src/community_follower_view.rs
@@ -1,19 +1,21 @@
 use crate::structs::CommunityFollowerView;
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{CommunityId, PersonId},
   schema::{community, community_follower, person},
   source::{community::Community, person::Person},
   traits::JoinView,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type CommunityFollowerViewTuple = (Community, Person);
 
 impl CommunityFollowerView {
-  pub async fn for_community(pool: &DbPool, community_id: CommunityId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_community(
+    pool: DbPoolRef<'_>,
+    community_id: CommunityId,
+  ) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_follower::table
       .inner_join(community::table)
       .inner_join(person::table)
@@ -26,8 +28,8 @@ impl CommunityFollowerView {
     Ok(res.into_iter().map(Self::from_tuple).collect())
   }
 
-  pub async fn for_person(pool: &DbPool, person_id: PersonId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_person(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_follower::table
       .inner_join(community::table)
       .inner_join(person::table)
diff --git a/crates/db_views_actor/src/community_moderator_view.rs b/crates/db_views_actor/src/community_moderator_view.rs
index afdfbfb28..1a7145f65 100644
--- a/crates/db_views_actor/src/community_moderator_view.rs
+++ b/crates/db_views_actor/src/community_moderator_view.rs
@@ -1,19 +1,21 @@
 use crate::structs::CommunityModeratorView;
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{CommunityId, PersonId},
   schema::{community, community_moderator, person},
   source::{community::Community, person::Person},
   traits::JoinView,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type CommunityModeratorViewTuple = (Community, Person);
 
 impl CommunityModeratorView {
-  pub async fn for_community(pool: &DbPool, community_id: CommunityId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_community(
+    pool: DbPoolRef<'_>,
+    community_id: CommunityId,
+  ) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_moderator::table
       .inner_join(community::table)
       .inner_join(person::table)
@@ -25,8 +27,8 @@ impl CommunityModeratorView {
     Ok(res.into_iter().map(Self::from_tuple).collect())
   }
 
-  pub async fn for_person(pool: &DbPool, person_id: PersonId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_person(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_moderator::table
       .inner_join(community::table)
       .inner_join(person::table)
@@ -42,8 +44,8 @@ impl CommunityModeratorView {
 
   /// Finds all communities first mods / creators
   /// Ideally this should be a group by, but diesel doesn't support it yet
-  pub async fn get_community_first_mods(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn get_community_first_mods(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let res = community_moderator::table
       .inner_join(community::table)
       .inner_join(person::table)
diff --git a/crates/db_views_actor/src/community_person_ban_view.rs b/crates/db_views_actor/src/community_person_ban_view.rs
index 35eacf0f7..89ff7b1bd 100644
--- a/crates/db_views_actor/src/community_person_ban_view.rs
+++ b/crates/db_views_actor/src/community_person_ban_view.rs
@@ -1,20 +1,19 @@
 use crate::structs::CommunityPersonBanView;
 use diesel::{result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::{CommunityId, PersonId},
   schema::{community, community_person_ban, person},
   source::{community::Community, person::Person},
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 impl CommunityPersonBanView {
   pub async fn get(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     from_person_id: PersonId,
     from_community_id: CommunityId,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let (community, person) = community_person_ban::table
       .inner_join(community::table)
       .inner_join(person::table)
diff --git a/crates/db_views_actor/src/community_view.rs b/crates/db_views_actor/src/community_view.rs
index 94bcdaf92..5ade72998 100644
--- a/crates/db_views_actor/src/community_view.rs
+++ b/crates/db_views_actor/src/community_view.rs
@@ -8,7 +8,6 @@ use diesel::{
   PgTextExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::CommunityAggregates,
   newtypes::{CommunityId, PersonId},
@@ -19,7 +18,7 @@ use lemmy_db_schema::{
     local_user::LocalUser,
   },
   traits::JoinView,
-  utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
+  utils::{fuzzy_search, limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   ListingType,
   SortType,
 };
@@ -34,12 +33,12 @@ type CommunityViewTuple = (
 
 impl CommunityView {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     community_id: CommunityId,
     my_person_id: Option<PersonId>,
     is_mod_or_admin: Option<bool>,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     // The left join below will return None in this case
     let person_id_join = my_person_id.unwrap_or(PersonId(-1));
 
@@ -86,7 +85,7 @@ impl CommunityView {
   }
 
   pub async fn is_mod_or_admin(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_id: PersonId,
     community_id: CommunityId,
   ) -> Result<bool, Error> {
@@ -120,7 +119,7 @@ impl CommunityView {
 #[builder(field_defaults(default))]
 pub struct CommunityQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   listing_type: Option<ListingType>,
   sort: Option<SortType>,
   local_user: Option<&'a LocalUser>,
diff --git a/crates/db_views_actor/src/person_block_view.rs b/crates/db_views_actor/src/person_block_view.rs
index 6e10ee7b6..63d5d00a6 100644
--- a/crates/db_views_actor/src/person_block_view.rs
+++ b/crates/db_views_actor/src/person_block_view.rs
@@ -1,19 +1,18 @@
 use crate::structs::PersonBlockView;
 use diesel::{result::Error, ExpressionMethods, JoinOnDsl, QueryDsl};
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{person, person_block},
   source::person::Person,
   traits::JoinView,
-  utils::{get_conn, DbPool},
+  utils::{DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type PersonBlockViewTuple = (Person, Person);
 
 impl PersonBlockView {
-  pub async fn for_person(pool: &DbPool, person_id: PersonId) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn for_person(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let target_person_alias = diesel::alias!(person as person1);
 
     let res = person_block::table
diff --git a/crates/db_views_actor/src/person_mention_view.rs b/crates/db_views_actor/src/person_mention_view.rs
index 803abdb39..a7ae7afb7 100644
--- a/crates/db_views_actor/src/person_mention_view.rs
+++ b/crates/db_views_actor/src/person_mention_view.rs
@@ -8,7 +8,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::CommentAggregates,
   newtypes::{PersonId, PersonMentionId},
@@ -34,7 +33,7 @@ use lemmy_db_schema::{
     post::Post,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   CommentSortType,
 };
 use typed_builder::TypedBuilder;
@@ -56,11 +55,11 @@ type PersonMentionViewTuple = (
 
 impl PersonMentionView {
   pub async fn read(
-    pool: &DbPool,
+    pool: DbPoolRef<'_>,
     person_mention_id: PersonMentionId,
     my_person_id: Option<PersonId>,
   ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
 
     // The left join below will return None in this case
@@ -156,9 +155,12 @@ impl PersonMentionView {
   }
 
   /// Gets the number of unread mentions
-  pub async fn get_unread_mentions(pool: &DbPool, my_person_id: PersonId) -> Result<i64, Error> {
+  pub async fn get_unread_mentions(
+    pool: DbPoolRef<'_>,
+    my_person_id: PersonId,
+  ) -> Result<i64, Error> {
     use diesel::dsl::count;
-    let conn = &mut get_conn(pool).await?;
+    let conn = pool;
 
     person_mention::table
       .inner_join(comment::table)
@@ -176,7 +178,7 @@ impl PersonMentionView {
 #[builder(field_defaults(default))]
 pub struct PersonMentionQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   my_person_id: Option<PersonId>,
   recipient_id: Option<PersonId>,
   sort: Option<CommentSortType>,
diff --git a/crates/db_views_actor/src/person_view.rs b/crates/db_views_actor/src/person_view.rs
index 2a7a2ce79..a4e203871 100644
--- a/crates/db_views_actor/src/person_view.rs
+++ b/crates/db_views_actor/src/person_view.rs
@@ -7,14 +7,13 @@ use diesel::{
   PgTextExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   aggregates::structs::PersonAggregates,
   newtypes::PersonId,
   schema::{person, person_aggregates},
   source::person::Person,
   traits::JoinView,
-  utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
+  utils::{fuzzy_search, limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
   SortType,
 };
 use std::iter::Iterator;
@@ -23,8 +22,8 @@ use typed_builder::TypedBuilder;
 type PersonViewTuple = (Person, PersonAggregates);
 
 impl PersonView {
-  pub async fn read(pool: &DbPool, person_id: PersonId) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn read(pool: DbPoolRef<'_>, person_id: PersonId) -> Result<Self, Error> {
+    let conn = pool;
     let res = person::table
       .find(person_id)
       .inner_join(person_aggregates::table)
@@ -34,8 +33,8 @@ impl PersonView {
     Ok(Self::from_tuple(res))
   }
 
-  pub async fn admins(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn admins(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let admins = person::table
       .inner_join(person_aggregates::table)
       .select((person::all_columns, person_aggregates::all_columns))
@@ -48,8 +47,8 @@ impl PersonView {
     Ok(admins.into_iter().map(Self::from_tuple).collect())
   }
 
-  pub async fn banned(pool: &DbPool) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn banned(pool: DbPoolRef<'_>) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let banned = person::table
       .inner_join(person_aggregates::table)
       .select((person::all_columns, person_aggregates::all_columns))
@@ -72,7 +71,7 @@ impl PersonView {
 #[builder(field_defaults(default))]
 pub struct PersonQuery<'a> {
   #[builder(!default)]
-  pool: &'a DbPool,
+  pool: DbPoolRef<'a>,
   sort: Option<SortType>,
   search_term: Option<String>,
   page: Option<i64>,
diff --git a/crates/db_views_moderator/src/admin_purge_comment_view.rs b/crates/db_views_moderator/src/admin_purge_comment_view.rs
index 12e47fbbc..e9d59f5f1 100644
--- a/crates/db_views_moderator/src/admin_purge_comment_view.rs
+++ b/crates/db_views_moderator/src/admin_purge_comment_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{admin_purge_comment, person, post},
   source::{moderator::AdminPurgeComment, person::Person, post::Post},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type AdminPurgeCommentViewTuple = (AdminPurgeComment, Option<Person>, Post);
 
 impl AdminPurgeCommentView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
     let show_mod_names_expr = show_mod_names.as_sql::<diesel::sql_types::Bool>();
diff --git a/crates/db_views_moderator/src/admin_purge_community_view.rs b/crates/db_views_moderator/src/admin_purge_community_view.rs
index e3a7a7897..5224674aa 100644
--- a/crates/db_views_moderator/src/admin_purge_community_view.rs
+++ b/crates/db_views_moderator/src/admin_purge_community_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{admin_purge_community, person},
   source::{moderator::AdminPurgeCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type AdminPurgeCommunityViewTuple = (AdminPurgeCommunity, Option<Person>);
 
 impl AdminPurgeCommunityView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
     let show_mod_names_expr = show_mod_names.as_sql::<diesel::sql_types::Bool>();
diff --git a/crates/db_views_moderator/src/admin_purge_person_view.rs b/crates/db_views_moderator/src/admin_purge_person_view.rs
index fff5b2d51..66fb1409f 100644
--- a/crates/db_views_moderator/src/admin_purge_person_view.rs
+++ b/crates/db_views_moderator/src/admin_purge_person_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{admin_purge_person, person},
   source::{moderator::AdminPurgePerson, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type AdminPurgePersonViewTuple = (AdminPurgePerson, Option<Person>);
 
 impl AdminPurgePersonView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/admin_purge_post_view.rs b/crates/db_views_moderator/src/admin_purge_post_view.rs
index e37e66b1b..fa3eb6beb 100644
--- a/crates/db_views_moderator/src/admin_purge_post_view.rs
+++ b/crates/db_views_moderator/src/admin_purge_post_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{admin_purge_post, community, person},
   source::{community::Community, moderator::AdminPurgePost, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type AdminPurgePostViewTuple = (AdminPurgePost, Option<Person>, Community);
 
 impl AdminPurgePostView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_add_community_view.rs b/crates/db_views_moderator/src/mod_add_community_view.rs
index 6df6376f5..8959088f5 100644
--- a/crates/db_views_moderator/src/mod_add_community_view.rs
+++ b/crates/db_views_moderator/src/mod_add_community_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_add_community, person},
   source::{community::Community, moderator::ModAddCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModAddCommunityViewTuple = (ModAddCommunity, Option<Person>, Community, Person);
 
 impl ModAddCommunityView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_add_view.rs b/crates/db_views_moderator/src/mod_add_view.rs
index ef408ce3a..4c0e5cd5f 100644
--- a/crates/db_views_moderator/src/mod_add_view.rs
+++ b/crates/db_views_moderator/src/mod_add_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{mod_add, person},
   source::{moderator::ModAdd, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModAddViewTuple = (ModAdd, Option<Person>, Person);
 
 impl ModAddView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_ban_from_community_view.rs b/crates/db_views_moderator/src/mod_ban_from_community_view.rs
index c7fb73956..c829f81a8 100644
--- a/crates/db_views_moderator/src/mod_ban_from_community_view.rs
+++ b/crates/db_views_moderator/src/mod_ban_from_community_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_ban_from_community, person},
   source::{community::Community, moderator::ModBanFromCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModBanFromCommunityViewTuple = (ModBanFromCommunity, Option<Person>, Community, Person);
 
 impl ModBanFromCommunityView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
diff --git a/crates/db_views_moderator/src/mod_ban_view.rs b/crates/db_views_moderator/src/mod_ban_view.rs
index 7bdf0dcf7..7077441f5 100644
--- a/crates/db_views_moderator/src/mod_ban_view.rs
+++ b/crates/db_views_moderator/src/mod_ban_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{mod_ban, person},
   source::{moderator::ModBan, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModBanViewTuple = (ModBan, Option<Person>, Person);
 
 impl ModBanView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_feature_post_view.rs b/crates/db_views_moderator/src/mod_feature_post_view.rs
index 66bd4264f..c8d4a8624 100644
--- a/crates/db_views_moderator/src/mod_feature_post_view.rs
+++ b/crates/db_views_moderator/src/mod_feature_post_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_feature_post, person, post},
   source::{community::Community, moderator::ModFeaturePost, person::Person, post::Post},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModFeaturePostViewTuple = (ModFeaturePost, Option<Person>, Post, Community);
 
 impl ModFeaturePostView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_hide_community_view.rs b/crates/db_views_moderator/src/mod_hide_community_view.rs
index c2c6294bf..a569ebe22 100644
--- a/crates/db_views_moderator/src/mod_hide_community_view.rs
+++ b/crates/db_views_moderator/src/mod_hide_community_view.rs
@@ -8,21 +8,20 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_hide_community, person},
   source::{community::Community, moderator::ModHideCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModHideCommunityViewTuple = (ModHideCommunity, Option<Person>, Community);
 
 impl ModHideCommunityView {
   // Pass in mod_id as admin_id because only admins can do this action
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_lock_post_view.rs b/crates/db_views_moderator/src/mod_lock_post_view.rs
index 15ff7855c..9a8a0ce42 100644
--- a/crates/db_views_moderator/src/mod_lock_post_view.rs
+++ b/crates/db_views_moderator/src/mod_lock_post_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_lock_post, person, post},
   source::{community::Community, moderator::ModLockPost, person::Person, post::Post},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModLockPostViewTuple = (ModLockPost, Option<Person>, Post, Community);
 
 impl ModLockPostView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
diff --git a/crates/db_views_moderator/src/mod_remove_comment_view.rs b/crates/db_views_moderator/src/mod_remove_comment_view.rs
index 0d33974b8..55c5c521b 100644
--- a/crates/db_views_moderator/src/mod_remove_comment_view.rs
+++ b/crates/db_views_moderator/src/mod_remove_comment_view.rs
@@ -8,7 +8,6 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{comment, community, mod_remove_comment, person, post},
@@ -20,7 +19,7 @@ use lemmy_db_schema::{
     post::Post,
   },
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModRemoveCommentViewTuple = (
@@ -33,8 +32,8 @@ type ModRemoveCommentViewTuple = (
 );
 
 impl ModRemoveCommentView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let person_alias_1 = diesel::alias!(lemmy_db_schema::schema::person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
diff --git a/crates/db_views_moderator/src/mod_remove_community_view.rs b/crates/db_views_moderator/src/mod_remove_community_view.rs
index 50f99e528..e5a997051 100644
--- a/crates/db_views_moderator/src/mod_remove_community_view.rs
+++ b/crates/db_views_moderator/src/mod_remove_community_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_remove_community, person},
   source::{community::Community, moderator::ModRemoveCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModRemoveCommunityTuple = (ModRemoveCommunity, Option<Person>, Community);
 
 impl ModRemoveCommunityView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
     let show_mod_names = !params.hide_modlog_names;
     let show_mod_names_expr = show_mod_names.as_sql::<diesel::sql_types::Bool>();
diff --git a/crates/db_views_moderator/src/mod_remove_post_view.rs b/crates/db_views_moderator/src/mod_remove_post_view.rs
index fff5df466..5a9c40eb4 100644
--- a/crates/db_views_moderator/src/mod_remove_post_view.rs
+++ b/crates/db_views_moderator/src/mod_remove_post_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_remove_post, person, post},
   source::{community::Community, moderator::ModRemovePost, person::Person, post::Post},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModRemovePostViewTuple = (ModRemovePost, Option<Person>, Post, Community);
 
 impl ModRemovePostView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
diff --git a/crates/db_views_moderator/src/mod_transfer_community_view.rs b/crates/db_views_moderator/src/mod_transfer_community_view.rs
index 60da8e83f..ca0ae0728 100644
--- a/crates/db_views_moderator/src/mod_transfer_community_view.rs
+++ b/crates/db_views_moderator/src/mod_transfer_community_view.rs
@@ -8,20 +8,19 @@ use diesel::{
   NullableExpressionMethods,
   QueryDsl,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_db_schema::{
   newtypes::PersonId,
   schema::{community, mod_transfer_community, person},
   source::{community::Community, moderator::ModTransferCommunity, person::Person},
   traits::JoinView,
-  utils::{get_conn, limit_and_offset, DbPool},
+  utils::{limit_and_offset, DbPool, DbPoolRef, RunQueryDsl},
 };
 
 type ModTransferCommunityViewTuple = (ModTransferCommunity, Option<Person>, Community, Person);
 
 impl ModTransferCommunityView {
-  pub async fn list(pool: &DbPool, params: ModlogListParams) -> Result<Vec<Self>, Error> {
-    let conn = &mut get_conn(pool).await?;
+  pub async fn list(pool: DbPoolRef<'_>, params: ModlogListParams) -> Result<Vec<Self>, Error> {
+    let conn = pool;
 
     let person_alias_1 = diesel::alias!(person as person1);
     let admin_person_id_join = params.mod_person_id.unwrap_or(PersonId(-1));
diff --git a/crates/routes/src/feeds.rs b/crates/routes/src/feeds.rs
index 2d894c683..bebb376ab 100644
--- a/crates/routes/src/feeds.rs
+++ b/crates/routes/src/feeds.rs
@@ -8,6 +8,7 @@ use lemmy_db_schema::{
   traits::{ApubActor, Crud},
   utils::DbPool,
   CommentSortType,
+  DbPoolRef,
   ListingType,
   SortType,
 };
@@ -122,10 +123,10 @@ async fn get_feed_data(
   limit: i64,
   page: i64,
 ) -> Result<HttpResponse, LemmyError> {
-  let site_view = SiteView::read_local(context.pool()).await?;
+  let site_view = SiteView::read_local(&mut context.pool()).await?;
 
   let posts = PostQuery::builder()
-    .pool(context.pool())
+    .pool(&mut context.pool())
     .listing_type(Some(listing_type))
     .sort(Some(sort_type))
     .limit(Some(limit))
@@ -178,7 +179,7 @@ async fn get_feed(
   let builder = match request_type {
     RequestType::User => {
       get_feed_user(
-        context.pool(),
+        &mut context.pool(),
         &info.sort_type()?,
         &info.get_limit(),
         &info.get_page(),
@@ -189,7 +190,7 @@ async fn get_feed(
     }
     RequestType::Community => {
       get_feed_community(
-        context.pool(),
+        &mut context.pool(),
         &info.sort_type()?,
         &info.get_limit(),
         &info.get_page(),
@@ -200,7 +201,7 @@ async fn get_feed(
     }
     RequestType::Front => {
       get_feed_front(
-        context.pool(),
+        &mut context.pool(),
         &jwt_secret,
         &info.sort_type()?,
         &info.get_limit(),
@@ -211,7 +212,13 @@ async fn get_feed(
       .await
     }
     RequestType::Inbox => {
-      get_feed_inbox(context.pool(), &jwt_secret, &param, &protocol_and_hostname).await
+      get_feed_inbox(
+        &mut context.pool(),
+        &jwt_secret,
+        &param,
+        &protocol_and_hostname,
+      )
+      .await
     }
   }
   .map_err(ErrorBadRequest)?;
@@ -227,7 +234,7 @@ async fn get_feed(
 
 #[tracing::instrument(skip_all)]
 async fn get_feed_user(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   sort_type: &SortType,
   limit: &i64,
   page: &i64,
@@ -262,7 +269,7 @@ async fn get_feed_user(
 
 #[tracing::instrument(skip_all)]
 async fn get_feed_community(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   sort_type: &SortType,
   limit: &i64,
   page: &i64,
@@ -300,7 +307,7 @@ async fn get_feed_community(
 
 #[tracing::instrument(skip_all)]
 async fn get_feed_front(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   jwt_secret: &str,
   sort_type: &SortType,
   limit: &i64,
@@ -341,7 +348,7 @@ async fn get_feed_front(
 
 #[tracing::instrument(skip_all)]
 async fn get_feed_inbox(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   jwt_secret: &str,
   jwt: &str,
   protocol_and_hostname: &str,
diff --git a/crates/routes/src/images.rs b/crates/routes/src/images.rs
index 9b7801f2a..b79a38ffd 100644
--- a/crates/routes/src/images.rs
+++ b/crates/routes/src/images.rs
@@ -129,7 +129,7 @@ async fn full_res(
   context: web::Data<LemmyContext>,
 ) -> Result<HttpResponse, Error> {
   // block access to images if instance is private and unauthorized, public
-  let local_site = LocalSite::read(context.pool())
+  let local_site = LocalSite::read(&mut context.pool())
     .await
     .map_err(error::ErrorBadRequest)?;
   if local_site.private_instance {
diff --git a/crates/routes/src/nodeinfo.rs b/crates/routes/src/nodeinfo.rs
index 124e1ea43..ef6544622 100644
--- a/crates/routes/src/nodeinfo.rs
+++ b/crates/routes/src/nodeinfo.rs
@@ -29,7 +29,7 @@ async fn node_info_well_known(
 }
 
 async fn node_info(context: web::Data<LemmyContext>) -> Result<HttpResponse, Error> {
-  let site_view = SiteView::read_local(context.pool())
+  let site_view = SiteView::read_local(&mut context.pool())
     .await
     .map_err(|_| ErrorBadRequest(LemmyError::from(anyhow!("not_found"))))?;
 
diff --git a/crates/routes/src/webfinger.rs b/crates/routes/src/webfinger.rs
index 79de351a8..72adc9502 100644
--- a/crates/routes/src/webfinger.rs
+++ b/crates/routes/src/webfinger.rs
@@ -38,11 +38,11 @@ async fn get_webfinger_response(
   let name = extract_webfinger_name(&info.resource, &context)?;
 
   let name_ = name.clone();
-  let user_id: Option<Url> = Person::read_from_name(context.pool(), &name_, false)
+  let user_id: Option<Url> = Person::read_from_name(&mut context.pool(), &name_, false)
     .await
     .ok()
     .map(|c| c.actor_id.into());
-  let community_id: Option<Url> = Community::read_from_name(context.pool(), &name, false)
+  let community_id: Option<Url> = Community::read_from_name(&mut context.pool(), &name, false)
     .await
     .ok()
     .map(|c| c.actor_id.into());
diff --git a/src/code_migrations.rs b/src/code_migrations.rs
index c69ce591c..1196fea78 100644
--- a/src/code_migrations.rs
+++ b/src/code_migrations.rs
@@ -7,7 +7,6 @@ use diesel::{
   QueryDsl,
   TextExpressionMethods,
 };
-use diesel_async::RunQueryDsl;
 use lemmy_api_common::{
   lemmy_db_views::structs::SiteView,
   utils::{
@@ -33,13 +32,16 @@ use lemmy_db_schema::{
     site::{Site, SiteInsertForm, SiteUpdateForm},
   },
   traits::Crud,
-  utils::{get_conn, naive_now, DbPool},
+  utils::{naive_now, DbPool, DbPoolRef, RunQueryDsl},
 };
 use lemmy_utils::{error::LemmyError, settings::structs::Settings};
 use tracing::info;
 use url::Url;
 
-pub async fn run_advanced_migrations(pool: &DbPool, settings: &Settings) -> Result<(), LemmyError> {
+pub async fn run_advanced_migrations(
+  pool: DbPoolRef<'_>,
+  settings: &Settings,
+) -> Result<(), LemmyError> {
   let protocol_and_hostname = &settings.get_protocol_and_hostname();
   user_updates_2020_04_02(pool, protocol_and_hostname).await?;
   community_updates_2020_04_02(pool, protocol_and_hostname).await?;
@@ -56,11 +58,11 @@ pub async fn run_advanced_migrations(pool: &DbPool, settings: &Settings) -> Resu
 }
 
 async fn user_updates_2020_04_02(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::person::dsl::{actor_id, local, person};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running user_updates_2020_04_02");
 
@@ -94,11 +96,11 @@ async fn user_updates_2020_04_02(
 }
 
 async fn community_updates_2020_04_02(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::community::dsl::{actor_id, community, local};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running community_updates_2020_04_02");
 
@@ -133,11 +135,11 @@ async fn community_updates_2020_04_02(
 }
 
 async fn post_updates_2020_04_03(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::post::dsl::{ap_id, local, post};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running post_updates_2020_04_03");
 
@@ -168,11 +170,11 @@ async fn post_updates_2020_04_03(
 }
 
 async fn comment_updates_2020_04_03(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::comment::dsl::{ap_id, comment, local};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running comment_updates_2020_04_03");
 
@@ -203,11 +205,11 @@ async fn comment_updates_2020_04_03(
 }
 
 async fn private_message_updates_2020_05_05(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::private_message::dsl::{ap_id, local, private_message};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running private_message_updates_2020_05_05");
 
@@ -240,11 +242,11 @@ async fn private_message_updates_2020_05_05(
 }
 
 async fn post_thumbnail_url_updates_2020_07_27(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   use lemmy_db_schema::schema::post::dsl::{post, thumbnail_url};
-  let conn = &mut get_conn(pool).await?;
+  let conn = pool;
 
   info!("Running post_thumbnail_url_updates_2020_07_27");
 
@@ -271,8 +273,8 @@ async fn post_thumbnail_url_updates_2020_07_27(
 
 /// We are setting inbox and follower URLs for local and remote actors alike, because for now
 /// all federated instances are also Lemmy and use the same URL scheme.
-async fn apub_columns_2021_02_02(pool: &DbPool) -> Result<(), LemmyError> {
-  let conn = &mut get_conn(pool).await?;
+async fn apub_columns_2021_02_02(pool: DbPoolRef<'_>) -> Result<(), LemmyError> {
+  let conn = pool;
   info!("Running apub_columns_2021_02_02");
   {
     use lemmy_db_schema::schema::person::dsl::{inbox_url, person, shared_inbox_url};
@@ -329,7 +331,7 @@ async fn apub_columns_2021_02_02(pool: &DbPool) -> Result<(), LemmyError> {
 /// Before this point, there is only a single value in the site table which refers to the local
 /// Lemmy instance, so thats all we need to update.
 async fn instance_actor_2022_01_28(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   protocol_and_hostname: &str,
 ) -> Result<(), LemmyError> {
   info!("Running instance_actor_2021_09_29");
@@ -358,8 +360,8 @@ async fn instance_actor_2022_01_28(
 /// key field is empty, generate a new keypair. It would be possible to regenerate only the pubkey,
 /// but thats more complicated and has no benefit, as federation is already broken for these actors.
 /// https://github.com/LemmyNet/lemmy/issues/2347
-async fn regenerate_public_keys_2022_07_05(pool: &DbPool) -> Result<(), LemmyError> {
-  let conn = &mut get_conn(pool).await?;
+async fn regenerate_public_keys_2022_07_05(pool: DbPoolRef<'_>) -> Result<(), LemmyError> {
+  let conn = pool;
   info!("Running regenerate_public_keys_2022_07_05");
 
   {
@@ -413,7 +415,7 @@ async fn regenerate_public_keys_2022_07_05(pool: &DbPool) -> Result<(), LemmyErr
 /// If a site already exists, the DB migration should generate a local_site row.
 /// This will only be run for brand new sites.
 async fn initialize_local_site_2022_10_10(
-  pool: &DbPool,
+  pool: DbPoolRef<'_>,
   settings: &Settings,
 ) -> Result<(), LemmyError> {
   info!("Running initialize_local_site_2022_10_10");
diff --git a/src/lib.rs b/src/lib.rs
index f84842fe0..4dda307c8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -130,7 +130,7 @@ pub async fn start_lemmy_server() -> Result<(), LemmyError> {
     .retry_count(settings.retry_count)
     .debug(cfg!(debug_assertions))
     .http_signature_compat(true)
-    .url_verifier(Box::new(VerifyUrlData(context.pool().clone())))
+    .url_verifier(Box::new(VerifyUrlData(&mut context.pool().clone())))
     .build()
     .await?;