127 lines
3.8 KiB
Rust
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()
|
|
}
|
|
]
|
|
)
|
|
}
|
|
}
|