Improve ergonomics of `Backup`

1 files changed, 20 insertions, 23 deletions

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);