ravenous-tools/weaponry/src/database.rs

127 lines
3.8 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 std::collections::HashMap;
/// 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,
) -> Result<Vec<T>, serde_rusqlite::Error>
where
T: DeserializeOwned + more_fields::FieldsAsMap,
{
let mut query_result = conn.prepare(&generate_select_query::<T>(table_name, None))?;
Ok(serde_rusqlite::from_rows::<T>(query_result.query([])?)
.filter_map(|s| s.ok())
.collect())
}
/// Generate a SELECT query with fields generated from a struct. Returns a String
/// filter MUST contain "WHERE" else the query will fail
#[inline]
fn generate_select_query<T: more_fields::FieldsAsMap>(
table_name: &str,
filter: Option<&str>,
) -> String {
format!(
"SELECT {} FROM {} {};",
T::attributes_map()
.into_iter()
.map(|(k, _v)| k)
.collect::<Vec<_>>()
.join(", "),
table_name,
filter.unwrap_or("")
)
}
/// Generate create table_name with fields as columns
/// This function expects a hash map containing (column name, sqlite type)
pub fn generate_database_query(table_name: &str, fields: HashMap<String, String>) -> 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::FieldsAsMap;
use pretty_assertions::assert_eq;
use serde::Deserialize;
#[derive(FieldsAsMap, Deserialize, Debug, PartialEq)]
struct TestStruct {
id: usize,
name: String,
}
fn mock_set_up(db_filename: &str) -> EquipementDatabase {
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("WHERE 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")
.unwrap();
tear_down(filename, conn.conn);
assert_eq!(
result,
vec![
TestStruct {
id: 1,
name: "dupont".to_string()
},
TestStruct {
id: 2,
name: "durand".to_string()
}
]
)
}
}