ravenous-tools/crates/weaponry/src/database.rs

144 lines
4.5 KiB
Rust

// Workspace: weaponry
// File: weaponry/src/database.rs
//! Database handiling module
//! Implements the basics deserialisation from a database to the weaponry components
//! Should dump whole database in a vec of structs from weaponry_structs
#![allow(dead_code)]
use rusqlite::{self};
use serde::de::DeserializeOwned;
use crate::error::FatalEquipementError;
/// Public function to get data from db. Returns the result as a vec with structs
pub fn get_data<T>(
conn: &rusqlite::Connection,
table_name: &str,
filter: Option<&str>,
) -> Result<Vec<T>, FatalEquipementError>
where
T: DeserializeOwned + more_fields::FieldsAsSlice,
{
let mut connection = conn.prepare(&generate_select_query::<T>(table_name, filter))?;
let rows = connection.query([])?;
serde_rusqlite::from_rows::<T>(rows)
.enumerate()
.map(|(row_id, result)| {
result.map_err(|error| FatalEquipementError::SerdeRusqlite { error, row_id })
})
.collect()
}
/// Generate a SELECT query with fields generated from a struct. Returns a SQL request as a String
#[inline]
#[coverage(off)] // INCORRECT: Error with line report
fn generate_select_query<T: more_fields::FieldsAsSlice>(
table_name: &str,
filter: Option<&str>,
) -> String {
format!(
"SELECT {} FROM {}{};",
T::attributes_slice()
.iter()
.map(|(k, _v)| k.to_owned())
.collect::<Vec<_>>()
.join(","),
table_name,
filter.map_or_else(String::default, |j| " WHERE ".to_string() + j)
)
}
/// Generate create table_name with fields as columns
/// This function expects a hash map containing (column name, sqlite type)
pub fn generate_create_table_query(table_name: &str, fields: &[(&str, &str)]) -> String {
format!(
"CREATE TABLE IF NOT EXISTS {} ({}, PRIMARY KEY('id' AUTOINCREMENT));",
table_name,
fields
.iter()
.map(|(k, v)| format!("{} {}", k, v))
.collect::<Vec<_>>()
.join(",")
)
}
#[cfg(test)]
mod test {
use super::*;
use crate::{
interfaces::RecipeDatabase, weaponry_structs::equipement_impl_database::EquipementDatabase,
};
use more_fields::FieldsAsSlice;
use pretty_assertions::assert_eq;
use serde::Deserialize;
#[derive(FieldsAsSlice, Deserialize, Debug, PartialEq)]
struct TestStruct {
#[INTEGER]
id: usize,
#[TEXT]
name: String,
}
/// setting up test db and table, also adding arbitrary data inside
fn mock_set_up(db_filename: &str) -> EquipementDatabase {
let _ = std::fs::remove_file(db_filename);
let equip_db = EquipementDatabase::new(db_filename).unwrap();
equip_db.conn.execute("CREATE TABLE IF NOT EXISTS TestStruct (id INTEGER UNIQUE, name TEXT, PRIMARY KEY('id' AUTOINCREMENT));",()).unwrap();
equip_db
.conn
.execute(
"INSERT INTO TestStruct (id, name) VALUES (1, 'dupont'), (2, 'durand');",
(),
)
.unwrap();
equip_db
}
/// tearing down all test setup
fn tear_down(filename: &str, db_conn: rusqlite::Connection) {
db_conn.close().unwrap();
std::fs::remove_file(filename).unwrap();
}
#[test]
fn test_generate_query() {
assert_eq!(
generate_select_query::<TestStruct>("TestStruct", None),
"SELECT id,name FROM TestStruct;"
);
assert_eq!(
generate_select_query::<TestStruct>("TestStruct", Some("id=id")),
"SELECT id,name FROM TestStruct WHERE id=id;"
);
}
#[test]
fn get_data_from_fields() {
let filename = "test.db";
let conn = mock_set_up(filename);
let result = conn
.serialize_vec_from_table::<TestStruct>("TestStruct", None)
.unwrap();
tear_down(filename, conn.conn);
assert_eq!(
result,
vec![
TestStruct {
id: 1,
name: "dupont".to_string()
},
TestStruct {
id: 2,
name: "durand".to_string()
}
]
)
}
#[test]
fn test_generate_create_table_query() {
let query = generate_create_table_query("TestStruct", TestStruct::attributes_slice());
assert_eq!(
query, "CREATE TABLE IF NOT EXISTS TestStruct (id INTEGER,name TEXT, PRIMARY KEY('id' AUTOINCREMENT));".to_string()
)
}
}