From 286b19361ca28494241f63a9908d59d509571ccb Mon Sep 17 00:00:00 2001
From: Owen Jacobson <owen@grimoire.ca>
Date: Sat, 5 Oct 2024 01:05:52 -0400
Subject: Improve ergonomics of `Backup`

---
 src/db/backup.rs | 43 ++++++++++++++++++++-----------------------
 1 file changed, 20 insertions(+), 23 deletions(-)

(limited to 'src/db/backup.rs')

diff --git a/src/db/backup.rs b/src/db/backup.rs
index 027c233..a6fe917 100644
--- a/src/db/backup.rs
+++ b/src/db/backup.rs
@@ -8,41 +8,38 @@ use libsqlite3_sys::{
     sqlite3, sqlite3_backup, sqlite3_backup_finish, sqlite3_backup_init, sqlite3_backup_step,
     sqlite3_errmsg, sqlite3_extended_errcode, SQLITE_BUSY, SQLITE_LOCKED, SQLITE_OK,
 };
-use sqlx::{
-    pool::PoolConnection,
-    sqlite::{Sqlite, SqlitePool},
-};
+use sqlx::sqlite::SqlitePool;
 
-pub struct Builder {
-    from: PoolConnection<Sqlite>,
+pub struct Builder<'p> {
+    from: &'p SqlitePool,
 }
 
-impl Builder {
-    pub async fn to(self, to: &SqlitePool) -> sqlx::Result<Backup> {
-        Ok(Backup {
+impl<'p> Builder<'p> {
+    pub fn to(self, to: &'p SqlitePool) -> Backup<'p> {
+        Backup {
             from: self.from,
-            to: to.acquire().await?,
-        })
+            to,
+        }
     }
 }
 
-impl Backup {
-    pub async fn from(from: &SqlitePool) -> sqlx::Result<Builder> {
-        Ok(Builder {
-            from: from.acquire().await?,
-        })
-    }
+pub struct Backup<'p> {
+    from: &'p SqlitePool,
+    to: &'p SqlitePool,
 }
 
-pub struct Backup {
-    from: PoolConnection<Sqlite>,
-    to: PoolConnection<Sqlite>,
+impl<'p> Backup<'p> {
+    pub fn from(from: &'p SqlitePool) -> Builder<'p> {
+        Builder { from }
+    }
 }
 
-impl Backup {
+impl<'p> Backup<'p> {
     pub async fn backup(&mut self) -> Result<(), Error> {
-        let mut to = self.to.lock_handle().await?;
-        let mut from = self.from.lock_handle().await?;
+        let mut to = self.to.acquire().await?;
+        let mut to = to.lock_handle().await?;
+        let mut from = self.from.acquire().await?;
+        let mut from = from.lock_handle().await?;
 
         let handle = Self::start(to.as_raw_handle(), from.as_raw_handle())?;
         let step_result = Self::step(handle, -1);
-- 
cgit v1.2.3