ethanaobrien/ew
1
0
Fork 0
mirror of https://git.ethanthesleepy.one/ethanaobrien/ew.git synced 2025-05-13 11:37:33 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move back to mutex in sql.rs

Browse source
This commit is contained in:
Ethan O'Brien 2024-11-21 11:13:54 -06:00
parent 7493724cd7
commit b21deaee5f
1 changed files with 57 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

137
src/sql.rs
View file

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