From fc4c1df09a57add7f9f5860f0f169cfdf3c8b8f2 Mon Sep 17 00:00:00 2001 From: Tobias Reisinger Date: Thu, 2 May 2024 19:35:22 +0200 Subject: [PATCH] Revert "Add sql transactions" This caused the error "locked database". This reverts commit 19e2ea003b577b738d4aa962c78bb28220af89ca. --- src/db/controllers.rs | 58 ++++++++++++++-------------- src/db/junction_relay_schedule.rs | 36 ++++++++--------- src/db/junction_tag.rs | 10 ++--- src/db/macro.rs | 54 +++++++++++++------------- src/db/macro_action.rs | 30 +++++++-------- src/db/mod.rs | 8 ++-- src/db/relays.rs | 62 +++++++++++++++--------------- src/db/schedules.rs | 64 +++++++++++++++---------------- src/db/tag.rs | 30 +++++++-------- src/models/controller.rs | 18 ++++----- src/models/macro.rs | 12 +++--- src/models/macro_action.rs | 20 +++++----- src/models/mod.rs | 20 +++++----- src/models/relay.rs | 28 +++++++------- src/models/schedule.rs | 10 ++--- src/models/tag.rs | 16 ++++---- src/types/request.rs | 6 +-- 17 files changed, 240 insertions(+), 242 deletions(-) diff --git a/src/db/controllers.rs b/src/db/controllers.rs index 79cb0df..bf0a1f0 100644 --- a/src/db/controllers.rs +++ b/src/db/controllers.rs @@ -1,7 +1,7 @@ use std::ops::DerefMut; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbRelay, DbTag}; @@ -21,26 +21,26 @@ pub struct DbController { impl DbController { pub async fn get_all( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_as!(DbController, "SELECT * FROM controllers") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!(DbController, "SELECT * FROM controllers WHERE id = ?", id) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: &EmgauwaUid, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -48,39 +48,39 @@ impl DbController { "SELECT * FROM controllers WHERE uid = ?", filter_uid ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_uid_or_create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, uid: &EmgauwaUid, new_name: &str, new_relay_count: i64, ) -> Result { - match DbController::get_by_uid(tx, uid).await? { + match DbController::get_by_uid(conn, uid).await? { Some(tag) => Ok(tag), - None => DbController::create(tx, uid, new_name, new_relay_count).await, + None => DbController::create(conn, uid, new_name, new_relay_count).await, } } pub async fn get_by_tag( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, tag: &DbTag, ) -> Result, DatabaseError> { sqlx::query_as!(DbController, "SELECT schedule.* FROM controllers AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn delete_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: EmgauwaUid, ) -> Result<(), DatabaseError> { if sqlx::query_scalar!("SELECT 1 FROM controllers WHERE uid = ?", filter_uid) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .is_none() { @@ -88,7 +88,7 @@ impl DbController { } sqlx::query!("DELETE FROM controllers WHERE uid = ?", filter_uid) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -97,7 +97,7 @@ impl DbController { } pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_uid: &EmgauwaUid, new_name: &str, new_relay_count: i64, @@ -109,14 +109,14 @@ impl DbController { new_name, new_relay_count, ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } pub async fn update( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_name: &str, new_relay_count: i64, ) -> Result { @@ -126,17 +126,17 @@ impl DbController { new_relay_count, self.id, ) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - Self::get(tx, self.id) + Self::get(conn, self.id) .await? .ok_or(DatabaseError::UpdateGetError) } pub async fn update_active( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_active: bool, ) -> Result { sqlx::query!( @@ -144,40 +144,40 @@ impl DbController { new_active, self.id, ) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - Self::get(tx, self.id) + Self::get(conn, self.id) .await? .ok_or(DatabaseError::UpdateGetError) } pub async fn get_relays( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_as!( DbRelay, "SELECT * FROM relays WHERE controller_id = ?", self.id ) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } - pub async fn all_inactive(tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> { + pub async fn all_inactive(conn: &mut PoolConnection) -> Result<(), DatabaseError> { sqlx::query!("UPDATE controllers SET active = 0") - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; Ok(()) } pub async fn reload( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - Self::get(tx, self.id) + Self::get(conn, self.id) .await? .ok_or(DatabaseError::NotFound) } diff --git a/src/db/junction_relay_schedule.rs b/src/db/junction_relay_schedule.rs index 74710eb..f081a54 100644 --- a/src/db/junction_relay_schedule.rs +++ b/src/db/junction_relay_schedule.rs @@ -1,6 +1,6 @@ use std::ops::DerefMut; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbRelay, DbSchedule}; @@ -16,7 +16,7 @@ pub struct DbJunctionRelaySchedule { impl DbJunctionRelaySchedule { pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -24,13 +24,13 @@ impl DbJunctionRelaySchedule { "SELECT * FROM junction_relay_schedule WHERE id = ?", id ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_junction_by_relay_and_weekday( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, relay: &DbRelay, weekday: Weekday, ) -> Result, DatabaseError> { @@ -40,13 +40,13 @@ impl DbJunctionRelaySchedule { relay.id, weekday ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_relays( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, schedule: &DbSchedule, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -57,13 +57,13 @@ impl DbJunctionRelaySchedule { ORDER BY junction_relay_schedule.weekday"#, schedule.id ) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_schedule( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, relay: &DbRelay, weekday: Weekday, ) -> Result, DatabaseError> { @@ -75,13 +75,13 @@ impl DbJunctionRelaySchedule { relay.id, weekday ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_schedules( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, relay: &DbRelay, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -92,18 +92,18 @@ impl DbJunctionRelaySchedule { ORDER BY junction_relay_schedule.weekday"#, relay.id ) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn set_schedule( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, relay: &DbRelay, schedule: &DbSchedule, weekday: Weekday, ) -> Result { - match Self::get_junction_by_relay_and_weekday(tx, relay, weekday).await? { + match Self::get_junction_by_relay_and_weekday(conn, relay, weekday).await? { None => sqlx::query_as!( DbJunctionRelaySchedule, "INSERT INTO junction_relay_schedule (weekday, relay_id, schedule_id) VALUES (?, ?, ?) RETURNING *", @@ -111,7 +111,7 @@ impl DbJunctionRelaySchedule { relay.id, schedule.id ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError), @@ -123,10 +123,10 @@ impl DbJunctionRelaySchedule { schedule.id, junction.id ) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - Self::get(tx, junction.id) + Self::get(conn, junction.id) .await? .ok_or(DatabaseError::UpdateGetError) } @@ -134,12 +134,12 @@ impl DbJunctionRelaySchedule { } pub async fn set_schedules( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, relay: &DbRelay, schedules: Vec<&DbSchedule>, ) -> Result<(), DatabaseError> { for (weekday, schedule) in schedules.iter().enumerate() { - Self::set_schedule(tx, relay, schedule, weekday as Weekday).await?; + Self::set_schedule(conn, relay, schedule, weekday as Weekday).await?; } Ok(()) } diff --git a/src/db/junction_tag.rs b/src/db/junction_tag.rs index 51a3ba5..f1b8816 100644 --- a/src/db/junction_tag.rs +++ b/src/db/junction_tag.rs @@ -1,6 +1,6 @@ use std::ops::DerefMut; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbRelay, DbSchedule, DbTag}; @@ -15,7 +15,7 @@ pub struct DbJunctionTag { impl DbJunctionTag { pub async fn link_relay( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, tag: &DbTag, relay: &DbRelay, ) -> Result { @@ -25,13 +25,13 @@ impl DbJunctionTag { tag.id, relay.id ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } pub async fn link_schedule( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, tag: &DbTag, schedule: &DbSchedule, ) -> Result { @@ -41,7 +41,7 @@ impl DbJunctionTag { tag.id, schedule.id ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } diff --git a/src/db/macro.rs b/src/db/macro.rs index 6aa857c..62092ea 100644 --- a/src/db/macro.rs +++ b/src/db/macro.rs @@ -1,7 +1,7 @@ use std::ops::DerefMut; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbController, DbMacroAction, DbRelay, DbSchedule}; @@ -18,35 +18,35 @@ pub struct DbMacro { } impl DbMacro { - pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result, DatabaseError> { + pub async fn get_all(conn: &mut PoolConnection) -> Result, DatabaseError> { sqlx::query_as!(DbMacro, "SELECT * FROM macros") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE id = ?", id) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: &EmgauwaUid, ) -> Result, DatabaseError> { sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE uid = ?", filter_uid) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_uid: EmgauwaUid, new_name: &str, ) -> Result { @@ -56,14 +56,14 @@ impl DbMacro { new_uid, new_name ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } - pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> { + pub async fn delete(&self, conn: &mut PoolConnection) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM macros WHERE id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -72,11 +72,11 @@ impl DbMacro { } pub async fn delete_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: EmgauwaUid, ) -> Result<(), DatabaseError> { if sqlx::query_scalar!("SELECT 1 FROM macros WHERE uid = ?", filter_uid) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .is_none() { @@ -84,7 +84,7 @@ impl DbMacro { } sqlx::query!("DELETE FROM macros WHERE uid = ?", filter_uid) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -94,62 +94,62 @@ impl DbMacro { pub async fn update( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_name: &str, ) -> Result { sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - DbMacro::get(tx, self.id) + DbMacro::get(conn, self.id) .await? .ok_or(DatabaseError::UpdateGetError) } pub async fn set_actions( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_actions: &[RequestMacroAction], ) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM macro_actions WHERE macro_id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; for new_action in new_actions { - let controller = DbController::get_by_uid(tx, &new_action.relay.controller_id) + let controller = DbController::get_by_uid(conn, &new_action.relay.controller_id) .await? .ok_or(DatabaseError::NotFound)?; let relay = - DbRelay::get_by_controller_and_num(tx, &controller, new_action.relay.number) + DbRelay::get_by_controller_and_num(conn, &controller, new_action.relay.number) .await? .ok_or(DatabaseError::NotFound)?; - let schedule = DbSchedule::get_by_uid(tx, &new_action.schedule.id) + let schedule = DbSchedule::get_by_uid(conn, &new_action.schedule.id) .await? .ok_or(DatabaseError::NotFound)?; - DbMacroAction::create(tx, self, &relay, &schedule, new_action.weekday).await?; + DbMacroAction::create(conn, self, &relay, &schedule, new_action.weekday).await?; } Ok(()) } pub async fn get_actions( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_as!( DbMacroAction, "SELECT * FROM macro_actions WHERE macro_id = ?", self.id ) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_actions_weekday( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, weekday: i64, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -158,7 +158,7 @@ impl DbMacro { self.id, weekday ) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } diff --git a/src/db/macro_action.rs b/src/db/macro_action.rs index a640dff..81e0a01 100644 --- a/src/db/macro_action.rs +++ b/src/db/macro_action.rs @@ -1,6 +1,6 @@ use std::ops::DerefMut; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbMacro, DbRelay, DbSchedule}; @@ -17,16 +17,16 @@ pub struct DbMacroAction { impl DbMacroAction { pub async fn get_all( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_as!(DbMacroAction, "SELECT * FROM macro_actions") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -34,13 +34,13 @@ impl DbMacroAction { "SELECT * FROM macro_actions WHERE id = ?", id ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_macro: &DbMacro, new_relay: &DbRelay, new_schedule: &DbSchedule, @@ -54,14 +54,14 @@ impl DbMacroAction { new_schedule.id, new_weekday ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } - pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> { + pub async fn delete(&self, conn: &mut PoolConnection) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM macro_actions WHERE id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -71,27 +71,27 @@ impl DbMacroAction { pub async fn get_relay( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - DbRelay::get(tx, self.relay_id) + DbRelay::get(conn, self.relay_id) .await? .ok_or(DatabaseError::NotFound) } pub async fn get_schedule( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - DbSchedule::get(tx, self.schedule_id) + DbSchedule::get(conn, self.schedule_id) .await? .ok_or(DatabaseError::NotFound) } pub async fn get_macro( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - DbMacro::get(tx, self.macro_id) + DbMacro::get(conn, self.macro_id) .await? .ok_or(DatabaseError::NotFound) } diff --git a/src/db/mod.rs b/src/db/mod.rs index 7de0263..7ebb6c3 100644 --- a/src/db/mod.rs +++ b/src/db/mod.rs @@ -46,12 +46,10 @@ pub async fn init(db: &str) -> Result, EmgauwaError> { run_migrations(&pool).await?; - let mut tx = pool.begin().await?; + let mut pool_conn = pool.acquire().await?; - DbSchedule::get_on(&mut tx).await?; - DbSchedule::get_off(&mut tx).await?; - - tx.commit().await?; + DbSchedule::get_on(&mut pool_conn).await?; + DbSchedule::get_off(&mut pool_conn).await?; Ok(pool) } diff --git a/src/db/relays.rs b/src/db/relays.rs index faa82f0..c7f4ca3 100644 --- a/src/db/relays.rs +++ b/src/db/relays.rs @@ -1,7 +1,7 @@ use std::ops::DerefMut; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbController, DbJunctionRelaySchedule, DbJunctionTag, DbSchedule, DbTag}; @@ -20,25 +20,25 @@ pub struct DbRelay { } impl DbRelay { - pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result, DatabaseError> { + pub async fn get_all(conn: &mut PoolConnection) -> Result, DatabaseError> { sqlx::query_as!(DbRelay, "SELECT * FROM relays") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!(DbRelay, "SELECT * FROM relays WHERE id = ?", id) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_controller_and_num( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, controller: &DbController, number: i64, ) -> Result, DatabaseError> { @@ -48,38 +48,38 @@ impl DbRelay { controller.id, number ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_controller_and_num_or_create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, controller: &DbController, number: i64, new_name: &str, ) -> Result<(DbRelay, bool), DatabaseError> { - match DbRelay::get_by_controller_and_num(tx, controller, number).await? { + match DbRelay::get_by_controller_and_num(conn, controller, number).await? { Some(relay) => Ok((relay, false)), None => { - let relay = DbRelay::create(tx, new_name, number, controller).await?; + let relay = DbRelay::create(conn, new_name, number, controller).await?; Ok((relay, true)) } } } pub async fn get_by_tag( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, tag: &DbTag, ) -> Result, DatabaseError> { sqlx::query_as!(DbRelay, "SELECT relay.* FROM relays AS relay INNER JOIN junction_tag ON junction_tag.relay_id = relay.id WHERE junction_tag.tag_id = ?", tag.id) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_name: &str, new_number: i64, new_controller: &DbController, @@ -91,14 +91,14 @@ impl DbRelay { new_number, new_controller.id, ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } - pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> { + pub async fn delete(&self, conn: &mut PoolConnection) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM relays WHERE id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -108,68 +108,68 @@ impl DbRelay { pub async fn update( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_name: &str, ) -> Result { sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - DbRelay::get(tx, self.id) + DbRelay::get(conn, self.id) .await? .ok_or(DatabaseError::UpdateGetError) } pub async fn get_controller( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - DbController::get(tx, self.controller_id) + DbController::get(conn, self.controller_id) .await? .ok_or(DatabaseError::NotFound) } pub async fn get_tags( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_scalar!("SELECT tag FROM tags INNER JOIN junction_tag ON junction_tag.tag_id = tags.id WHERE junction_tag.relay_id = ?", self.id) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn set_tags( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_tags: &[String], ) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM junction_tag WHERE relay_id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; for new_tag in new_tags { - let tag: DbTag = DbTag::get_by_tag_or_create(tx, new_tag).await?; - DbJunctionTag::link_relay(tx, &tag, self).await?; + let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?; + DbJunctionTag::link_relay(conn, &tag, self).await?; } Ok(()) } pub async fn reload( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - Self::get(tx, self.id) + Self::get(conn, self.id) .await? .ok_or(DatabaseError::NotFound) } pub async fn get_active_schedule( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { let weekday = utils::get_weekday(); - DbJunctionRelaySchedule::get_schedule(tx, self, weekday as Weekday) + DbJunctionRelaySchedule::get_schedule(conn, self, weekday as Weekday) .await? .ok_or(DatabaseError::NotFound) } diff --git a/src/db/schedules.rs b/src/db/schedules.rs index 334bc11..6a792fd 100644 --- a/src/db/schedules.rs +++ b/src/db/schedules.rs @@ -3,7 +3,7 @@ use std::ops::DerefMut; use chrono::NaiveTime; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::model_utils::Period; @@ -26,26 +26,26 @@ pub struct DbPeriods(pub Vec); impl DbSchedule { pub async fn get_all( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { sqlx::query_as!(DbSchedule, "SELECT * FROM schedules") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!(DbSchedule, "SELECT * FROM schedules WHERE id = ?", id) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: &ScheduleUid, ) -> Result, DatabaseError> { sqlx::query_as!( @@ -53,23 +53,23 @@ impl DbSchedule { "SELECT * FROM schedules WHERE uid = ?", filter_uid ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_tag( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, tag: &DbTag, ) -> Result, DatabaseError> { sqlx::query_as!(DbSchedule, "SELECT schedule.* FROM schedules AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn delete_by_uid( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_uid: ScheduleUid, ) -> Result<(), DatabaseError> { let filter_uid = match filter_uid { @@ -79,7 +79,7 @@ impl DbSchedule { }?; if sqlx::query_scalar!("SELECT 1 FROM schedules WHERE uid = ?", filter_uid) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .is_none() { @@ -87,7 +87,7 @@ impl DbSchedule { } sqlx::query!("DELETE FROM schedules WHERE uid = ?", filter_uid) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), @@ -96,7 +96,7 @@ impl DbSchedule { } pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_uid: ScheduleUid, new_name: &str, new_periods: &DbPeriods, @@ -108,45 +108,45 @@ impl DbSchedule { new_name, new_periods, ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } pub async fn get_by_uid_or_create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, uid: ScheduleUid, name: &str, periods: &DbPeriods, ) -> Result<(DbSchedule, bool), DatabaseError> { - match DbSchedule::get_by_uid(tx, &uid).await? { + match DbSchedule::get_by_uid(conn, &uid).await? { Some(schedule) => Ok((schedule, false)), None => { - let schedule = DbSchedule::create(tx, uid, name, periods).await?; + let schedule = DbSchedule::create(conn, uid, name, periods).await?; Ok((schedule, true)) } } } - pub async fn get_on(tx: &mut Transaction<'_, Sqlite>) -> Result { - if let Some(schedule) = DbSchedule::get_by_uid(tx, &ScheduleUid::On).await? { + pub async fn get_on(conn: &mut PoolConnection) -> Result { + if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::On).await? { return Ok(schedule); } let periods = DbPeriods(vec![Period::new_on()]); - Self::create(tx, ScheduleUid::On, "On", &periods).await + Self::create(conn, ScheduleUid::On, "On", &periods).await } - pub async fn get_off(tx: &mut Transaction<'_, Sqlite>) -> Result { - if let Some(schedule) = DbSchedule::get_by_uid(tx, &ScheduleUid::Off).await? { + pub async fn get_off(conn: &mut PoolConnection) -> Result { + if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::Off).await? { return Ok(schedule); } let periods = DbPeriods(vec![]); - Self::create(tx, ScheduleUid::Off, "Off", &periods).await + Self::create(conn, ScheduleUid::Off, "Off", &periods).await } pub async fn update( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_name: &str, new_periods: &DbPeriods, ) -> Result { @@ -162,35 +162,35 @@ impl DbSchedule { new_periods, self.id, ) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; - DbSchedule::get(tx, self.id) + DbSchedule::get(conn, self.id) .await? .ok_or(DatabaseError::UpdateGetError) } pub async fn get_tags( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result, DatabaseError> { Ok(sqlx::query_scalar!("SELECT tag FROM tags INNER JOIN junction_tag ON junction_tag.tag_id = tags.id WHERE junction_tag.schedule_id = ?", self.id) - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await?) } pub async fn set_tags( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_tags: &[String], ) -> Result<(), DatabaseError> { sqlx::query!("DELETE FROM junction_tag WHERE schedule_id = ?", self.id) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await?; for new_tag in new_tags { - let tag: DbTag = DbTag::get_by_tag_or_create(tx, new_tag).await?; - DbJunctionTag::link_schedule(tx, &tag, self).await?; + let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?; + DbJunctionTag::link_schedule(conn, &tag, self).await?; } Ok(()) } diff --git a/src/db/tag.rs b/src/db/tag.rs index 7093068..9c15f79 100644 --- a/src/db/tag.rs +++ b/src/db/tag.rs @@ -1,7 +1,7 @@ use std::ops::DerefMut; use serde_derive::Serialize; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::errors::DatabaseError; @@ -14,7 +14,7 @@ pub struct DbTag { impl DbTag { pub async fn create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, new_tag: &str, ) -> Result { if new_tag.is_empty() { @@ -26,54 +26,54 @@ impl DbTag { "INSERT INTO tags (tag) VALUES (?) RETURNING *", new_tag ) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .ok_or(DatabaseError::InsertGetError) } - pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result, DatabaseError> { + pub async fn get_all(conn: &mut PoolConnection) -> Result, DatabaseError> { sqlx::query_as!(DbTag, "SELECT * FROM tags") - .fetch_all(tx.deref_mut()) + .fetch_all(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, id: i64, ) -> Result, DatabaseError> { sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE id = ?", id) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn get_by_tag_or_create( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, target_tag: &str, ) -> Result { - match DbTag::get_by_tag(tx, target_tag).await? { + match DbTag::get_by_tag(conn, target_tag).await? { Some(tag) => Ok(tag), - None => DbTag::create(tx, target_tag).await, + None => DbTag::create(conn, target_tag).await, } } pub async fn get_by_tag( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, target_tag: &str, ) -> Result, DatabaseError> { sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE tag = ?", target_tag) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await .map_err(DatabaseError::from) } pub async fn delete_by_tag( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, filter_tag: &str, ) -> Result<(), DatabaseError> { if sqlx::query_scalar!("SELECT 1 FROM tags WHERE tag = ?", filter_tag) - .fetch_optional(tx.deref_mut()) + .fetch_optional(conn.deref_mut()) .await? .is_none() { @@ -81,7 +81,7 @@ impl DbTag { } sqlx::query!("DELETE FROM tags WHERE tag = ?", filter_tag) - .execute(tx.deref_mut()) + .execute(conn.deref_mut()) .await .map(|res| match res.rows_affected() { 0 => Err(DatabaseError::DeleteError), diff --git a/src/models/controller.rs b/src/models/controller.rs index 621a966..96d7b00 100644 --- a/src/models/controller.rs +++ b/src/models/controller.rs @@ -4,7 +4,7 @@ use actix::MessageResponse; use chrono::NaiveTime; use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::DbController; @@ -24,16 +24,16 @@ impl FromDbModel for Controller { type DbModelCache = Vec; fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - let relays_db = block_on(db_model.get_relays(tx))?; - let cache = convert_db_list_cache(tx, relays_db, db_model.clone())?; - Self::from_db_model_cache(tx, db_model, cache) + let relays_db = block_on(db_model.get_relays(conn))?; + let cache = convert_db_list_cache(conn, relays_db, db_model.clone())?; + Self::from_db_model_cache(conn, db_model, cache) } fn from_db_model_cache( - _tx: &mut Transaction<'_, Sqlite>, + _conn: &mut PoolConnection, db_model: Self::DbModel, cache: Self::DbModelCache, ) -> Result { @@ -45,10 +45,10 @@ impl FromDbModel for Controller { } impl Controller { - pub fn reload(&mut self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), EmgauwaError> { - self.c = block_on(self.c.reload(tx))?; + pub fn reload(&mut self, conn: &mut PoolConnection) -> Result<(), EmgauwaError> { + self.c = block_on(self.c.reload(conn))?; for relay in &mut self.relays { - relay.reload(tx)?; + relay.reload(conn)?; } Ok(()) } diff --git a/src/models/macro.rs b/src/models/macro.rs index 1ee8f1e..0598c0c 100644 --- a/src/models/macro.rs +++ b/src/models/macro.rs @@ -1,6 +1,6 @@ use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::DbMacro; @@ -19,19 +19,19 @@ impl FromDbModel for Macro { type DbModelCache = (); fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - Self::from_db_model_cache(tx, db_model, ()) + Self::from_db_model_cache(conn, db_model, ()) } fn from_db_model_cache( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, _cache: Self::DbModelCache, ) -> Result { - let actions_db = block_on(db_model.get_actions(tx))?; - let actions: Vec = convert_db_list(tx, actions_db)?; + let actions_db = block_on(db_model.get_actions(conn))?; + let actions: Vec = convert_db_list(conn, actions_db)?; Ok(Macro { m: db_model, diff --git a/src/models/macro_action.rs b/src/models/macro_action.rs index 7b12428..a36a45a 100644 --- a/src/models/macro_action.rs +++ b/src/models/macro_action.rs @@ -1,6 +1,6 @@ use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbJunctionRelaySchedule, DbMacroAction}; @@ -19,22 +19,22 @@ impl FromDbModel for MacroAction { type DbModelCache = (); fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - Self::from_db_model_cache(tx, db_model, ()) + Self::from_db_model_cache(conn, db_model, ()) } fn from_db_model_cache( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, _cache: Self::DbModelCache, ) -> Result { - let schedule_db = block_on(db_model.get_schedule(tx))?; - let schedule = Schedule::from_db_model(tx, schedule_db)?; + let schedule_db = block_on(db_model.get_schedule(conn))?; + let schedule = Schedule::from_db_model(conn, schedule_db)?; - let relay_db = block_on(db_model.get_relay(tx))?; - let relay = Relay::from_db_model(tx, relay_db)?; + let relay_db = block_on(db_model.get_relay(conn))?; + let relay = Relay::from_db_model(conn, relay_db)?; let weekday = db_model.weekday; @@ -47,8 +47,8 @@ impl FromDbModel for MacroAction { } impl MacroAction { - pub async fn execute(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), EmgauwaError> { - DbJunctionRelaySchedule::set_schedule(tx, &self.relay.r, &self.schedule.s, self.weekday) + pub async fn execute(&self, conn: &mut PoolConnection) -> Result<(), EmgauwaError> { + DbJunctionRelaySchedule::set_schedule(conn, &self.relay.r, &self.schedule.s, self.weekday) .await?; Ok(()) } diff --git a/src/models/mod.rs b/src/models/mod.rs index 58a40b9..570bf48 100644 --- a/src/models/mod.rs +++ b/src/models/mod.rs @@ -10,7 +10,7 @@ pub use macro_action::MacroAction; pub use r#macro::Macro; pub use relay::Relay; pub use schedule::Schedule; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; pub use tag::Tag; @@ -21,14 +21,14 @@ pub trait FromDbModel { type DbModelCache: Clone; fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result where Self: Sized; fn from_db_model_cache( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, cache: Self::DbModelCache, ) -> Result @@ -37,15 +37,15 @@ pub trait FromDbModel { } fn convert_db_list_generic( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_models: Vec, cache: Option, ) -> Result, DatabaseError> { let mut result: Vec = Vec::new(); for db_model in db_models { let new = match &cache { - Some(c) => T::from_db_model_cache(tx, db_model, c.clone()), - None => T::from_db_model(tx, db_model), + Some(c) => T::from_db_model_cache(conn, db_model, c.clone()), + None => T::from_db_model(conn, db_model), }?; result.push(new); } @@ -53,16 +53,16 @@ fn convert_db_list_generic( } pub fn convert_db_list( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_models: Vec, ) -> Result, DatabaseError> { - convert_db_list_generic(tx, db_models, None) + convert_db_list_generic(conn, db_models, None) } pub fn convert_db_list_cache( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_models: Vec, cache: T::DbModelCache, ) -> Result, DatabaseError> { - convert_db_list_generic(tx, db_models, Some(cache)) + convert_db_list_generic(conn, db_models, Some(cache)) } diff --git a/src/models/relay.rs b/src/models/relay.rs index 20c214d..e6ecd0f 100644 --- a/src/models/relay.rs +++ b/src/models/relay.rs @@ -3,7 +3,7 @@ use std::time::Instant; use chrono::NaiveTime; use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule}; @@ -32,23 +32,23 @@ impl FromDbModel for Relay { type DbModelCache = DbController; fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - let cache = block_on(db_model.get_controller(tx))?; - Self::from_db_model_cache(tx, db_model, cache) + let cache = block_on(db_model.get_controller(conn))?; + Self::from_db_model_cache(conn, db_model, cache) } fn from_db_model_cache( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, cache: Self::DbModelCache, ) -> Result { - let tags = block_on(db_model.get_tags(tx))?; + let tags = block_on(db_model.get_tags(conn))?; let controller_id = cache.uid.clone(); - let schedules = block_on(DbJunctionRelaySchedule::get_schedules(tx, &db_model))?; - let active_schedule = block_on(db_model.get_active_schedule(tx))?; + let schedules = block_on(DbJunctionRelaySchedule::get_schedules(conn, &db_model))?; + let active_schedule = block_on(db_model.get_active_schedule(conn))?; let is_on = None; @@ -66,19 +66,19 @@ impl FromDbModel for Relay { } impl Relay { - pub fn reload(&mut self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> { - self.r = block_on(self.r.reload(tx))?; - self.schedules = block_on(DbJunctionRelaySchedule::get_schedules(tx, &self.r))?; - self.reload_active_schedule(tx)?; + pub fn reload(&mut self, conn: &mut PoolConnection) -> Result<(), DatabaseError> { + self.r = block_on(self.r.reload(conn))?; + self.schedules = block_on(DbJunctionRelaySchedule::get_schedules(conn, &self.r))?; + self.reload_active_schedule(conn)?; Ok(()) } pub fn reload_active_schedule( &mut self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result<(), DatabaseError> { - self.active_schedule = block_on(self.r.get_active_schedule(tx))?; + self.active_schedule = block_on(self.r.get_active_schedule(conn))?; Ok(()) } diff --git a/src/models/schedule.rs b/src/models/schedule.rs index 7a7903f..9bf07b4 100644 --- a/src/models/schedule.rs +++ b/src/models/schedule.rs @@ -1,6 +1,6 @@ use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::DbSchedule; @@ -19,15 +19,15 @@ impl FromDbModel for Schedule { type DbModelCache = Vec; fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - let cache = block_on(db_model.get_tags(tx))?; - Self::from_db_model_cache(tx, db_model, cache) + let cache = block_on(db_model.get_tags(conn))?; + Self::from_db_model_cache(conn, db_model, cache) } fn from_db_model_cache( - _tx: &mut Transaction<'_, Sqlite>, + _conn: &mut PoolConnection, db_model: Self::DbModel, cache: Self::DbModelCache, ) -> Result { diff --git a/src/models/tag.rs b/src/models/tag.rs index a5370dc..7e23fb4 100644 --- a/src/models/tag.rs +++ b/src/models/tag.rs @@ -1,7 +1,7 @@ use actix::MessageResponse; use futures::executor::block_on; use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbRelay, DbSchedule, DbTag}; @@ -20,21 +20,21 @@ impl FromDbModel for Tag { type DbModelCache = (Vec, Vec); fn from_db_model( - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, db_model: Self::DbModel, ) -> Result { - let db_schedules = block_on(DbSchedule::get_by_tag(tx, &db_model))?; - let schedules: Vec = convert_db_list(tx, db_schedules)?; + let db_schedules = block_on(DbSchedule::get_by_tag(conn, &db_model))?; + let schedules: Vec = convert_db_list(conn, db_schedules)?; - let db_relays = block_on(DbRelay::get_by_tag(tx, &db_model))?; - let relays: Vec = convert_db_list(tx, db_relays)?; + let db_relays = block_on(DbRelay::get_by_tag(conn, &db_model))?; + let relays: Vec = convert_db_list(conn, db_relays)?; let cache = (relays, schedules); - Self::from_db_model_cache(tx, db_model, cache) + Self::from_db_model_cache(conn, db_model, cache) } fn from_db_model_cache( - _tx: &mut Transaction<'_, Sqlite>, + _conn: &mut PoolConnection, db_model: Self::DbModel, cache: Self::DbModelCache, ) -> Result { diff --git a/src/types/request.rs b/src/types/request.rs index eb09abe..5c9a927 100644 --- a/src/types/request.rs +++ b/src/types/request.rs @@ -1,5 +1,5 @@ use serde_derive::{Deserialize, Serialize}; -use sqlx::Transaction; +use sqlx::pool::PoolConnection; use sqlx::Sqlite; use crate::db::{DbPeriods, DbSchedule}; @@ -86,9 +86,9 @@ pub struct RequestMacroExecute { impl RequestScheduleId { pub async fn get_schedule( &self, - tx: &mut Transaction<'_, Sqlite>, + conn: &mut PoolConnection, ) -> Result { - DbSchedule::get_by_uid(tx, &self.id) + DbSchedule::get_by_uid(conn, &self.id) .await? .ok_or(DatabaseError::NotFound) }