From b21deaee5fade03c3a9f86ecd41fb841d19bbf72 Mon Sep 17 00:00:00 2001
From: Ethan O'Brien <ethan.a.obrien@gmail.com>
Date: Thu, 21 Nov 2024 11:13:54 -0600
Subject: [PATCH] Move back to mutex in sql.rs

---
 src/sql.rs | 137 ++++++++++++++++++++++-------------------------------
 1 file changed, 57 insertions(+), 80 deletions(-)

diff --git a/src/sql.rs b/src/sql.rs
index 569c4c2..b7b13d4 100644
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -4,9 +4,24 @@ use json::{JsonValue, array};
 
 use crate::router::clear_rate::Live;
 
+macro_rules! lock_onto_mutex {
+    ($mutex:expr) => {{
+        loop {
+            match $mutex.lock() {
+                Ok(value) => {
+                    break value;
+                }
+                Err(_) => {
+                    $mutex.clear_poison();
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+            }
+        }
+    }};
+}
+
 pub struct SQLite {
-    engine: Mutex<Connection>,
-    sleep_duration: u64
+    engine: Mutex<Connection>
 }
 
 impl SQLite {
@@ -14,98 +29,60 @@ impl SQLite {
         let conn = Connection::open(crate::get_data_path(path)).unwrap();
         conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap();
         let instance = SQLite {
-            engine: Mutex::new(conn),
-            sleep_duration: 10
+            engine: Mutex::new(conn)
         };
         setup(&instance);
         instance
     }
     pub fn lock_and_exec(&self, command: &str, args: &[&dyn ToSql]) {
-        loop {
-            match self.engine.lock() {
-                Ok(conn) => {
-                    conn.execute(command, args).unwrap();
-                    return;
-                }
-                Err(_) => {
-                    self.engine.clear_poison();
-                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
-                }
-            }
-        }
+        let conn = lock_onto_mutex!(self.engine);
+        conn.execute(command, args).unwrap();
     }
     pub fn lock_and_select(&self, command: &str, args: &[&dyn ToSql]) -> Result<String, rusqlite::Error> {
-        loop {
-            match self.engine.lock() {
-                Ok(conn) => {
-                    let mut stmt = conn.prepare(command)?;
-                    return stmt.query_row(args, |row| {
-                        match row.get::<usize, i64>(0) {
-                            Ok(val) => Ok(val.to_string()),
-                                          Err(_) => row.get(0)
-                        }
-                    });
-                }
-                Err(_) => {
-                    self.engine.clear_poison();
-                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
-                }
+        let conn = lock_onto_mutex!(self.engine);
+        let mut stmt = conn.prepare(command)?;
+        return stmt.query_row(args, |row| {
+            match row.get::<usize, i64>(0) {
+                Ok(val) => Ok(val.to_string()),
+                Err(_) => row.get(0)
             }
-        }
+        });
     }
     pub fn lock_and_select_all(&self, command: &str, args: &[&dyn ToSql]) -> Result<JsonValue, rusqlite::Error> {
-        loop {
-            match self.engine.lock() {
-                Ok(conn) => {
-                    let mut stmt = conn.prepare(command)?;
-                    let map = stmt.query_map(args, |row| {
-                        match row.get::<usize, i64>(0) {
-                            Ok(val) => Ok(val.to_string()),
-                                             Err(_) => row.get(0)
-                        }
-                    })?;
-                    let mut rv = array![];
-                    for val in map {
-                        let res = val?;
-                        match res.clone().parse::<i64>() {
-                            Ok(v) => rv.push(v).unwrap(),
-                            Err(_) => rv.push(res).unwrap()
-                        };
-                    }
-                    return Ok(rv);
-                }
-                Err(_) => {
-                    self.engine.clear_poison();
-                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
-                }
+        let conn = lock_onto_mutex!(self.engine);
+        let mut stmt = conn.prepare(command)?;
+        let map = stmt.query_map(args, |row| {
+            match row.get::<usize, i64>(0) {
+                Ok(val) => Ok(val.to_string()),
+                Err(_) => row.get(0)
             }
+        })?;
+        let mut rv = array![];
+        for val in map {
+            let res = val?;
+            match res.clone().parse::<i64>() {
+                Ok(v) => rv.push(v).unwrap(),
+                              Err(_) => rv.push(res).unwrap()
+            };
         }
+        return Ok(rv);
     }
     pub fn get_live_data(&self, id: i64) -> Result<Live, rusqlite::Error> {
-        loop {
-            match self.engine.lock() {
-                Ok(conn) => {
-                    let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?;
-                    return stmt.query_row(params!(id), |row| {
-                        Ok(Live {
-                            live_id: row.get(0)?,
-                           normal_failed: row.get(1)?,
-                           normal_pass: row.get(2)?,
-                           hard_failed: row.get(3)?,
-                           hard_pass: row.get(4)?,
-                           expert_failed: row.get(5)?,
-                           expert_pass: row.get(6)?,
-                           master_failed: row.get(7)?,
-                           master_pass: row.get(8)?,
-                        })
-                    });
-                }
-                Err(_) => {
-                    self.engine.clear_poison();
-                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
-                }
-            }
-        }
+        let conn = lock_onto_mutex!(self.engine);
+        let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?;
+        return stmt.query_row(params!(id), |row| {
+            Ok(Live {
+               live_id: row.get(0)?,
+               normal_failed: row.get(1)?,
+               normal_pass: row.get(2)?,
+               hard_failed: row.get(3)?,
+               hard_pass: row.get(4)?,
+               expert_failed: row.get(5)?,
+               expert_pass: row.get(6)?,
+               master_failed: row.get(7)?,
+               master_pass: row.get(8)?,
+            })
+        });
     }
     pub fn create_store_v2(&self, table: &str) {
         self.lock_and_exec(table, params!());