ryanmwangi/Compware
1
0
Fork 0
Code Issues Pull requests Releases Activity

test(db): add logging to tests

Browse source
This commit is contained in:
ryan 2025-03-06 15:09:28 +03:00
parent 6c2442a82b
commit 8ac1d77e06
1 changed files with 184 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

317
src/db.rs
View file

@ -1,13 +1,13 @@
#[cfg(feature = "ssr")] #[cfg(feature = "ssr")]
mod db_impl { mod db_impl {
use crate::models::item::Item;
use leptos::logging;
use leptos::logging::log;
use rusqlite::{Connection, Error}; use rusqlite::{Connection, Error};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::Mutex; use tokio::sync::Mutex;
use leptos::logging;
use std::collections::{HashMap, HashSet};
use crate::models::item::Item;
use leptos::logging::log;
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
@ -17,19 +17,29 @@ mod db_impl {
// Helper function to create test database // Helper function to create test database
async fn create_test_db() -> Database { async fn create_test_db() -> Database {
log!("[TEST] Creating in-memory test database");
let db = Database::new(":memory:").unwrap(); let db = Database::new(":memory:").unwrap();
db.create_schema().await.unwrap(); db.create_schema().await.unwrap();
log!("[TEST] Database schema created");
db db
} }
// Test database schema creation // Test database schema creation
#[tokio::test] #[tokio::test]
async fn test_schema_creation() { async fn test_schema_creation() {
log!("[TEST] Starting test_schema_creation");
let db = create_test_db().await; let db = create_test_db().await;
// Verify tables exist // Verify tables exist
let conn = db.conn.lock().await; let conn = db.conn.lock().await;
let mut stmt = conn.prepare("SELECT name FROM sqlite_master WHERE type='table'").unwrap(); let mut stmt = conn
let tables: Vec<String> = stmt.query_map([], |row| row.get(0)).unwrap().collect::<Result<_, _>>().unwrap(); .prepare("SELECT name FROM sqlite_master WHERE type='table'")
.unwrap();
let tables: Vec<String> = stmt
.query_map([], |row| row.get(0))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
assert!(tables.contains(&"urls".to_string())); assert!(tables.contains(&"urls".to_string()));
assert!(tables.contains(&"items".to_string())); assert!(tables.contains(&"items".to_string()));
@ -41,6 +51,7 @@ mod db_impl {
// Item Lifecycle Tests // Item Lifecycle Tests
#[tokio::test] #[tokio::test]
async fn test_full_item_lifecycle() { async fn test_full_item_lifecycle() {
log!("[TEST] Starting test_full_item_lifecycle");
let db = create_test_db().await; let db = create_test_db().await;
let test_url = "https://example.com"; let test_url = "https://example.com";
let test_item = Item { let test_item = Item {
@ -50,62 +61,87 @@ mod db_impl {
wikidata_id: Some("Q123".into()), wikidata_id: Some("Q123".into()),
custom_properties: vec![ custom_properties: vec![
("price".into(), "100".into()), ("price".into(), "100".into()),
("color".into(), "red".into()) ("color".into(), "red".into()),
].into_iter().collect(), ]
.into_iter()
.collect(),
}; };
// Test insertion // Test insertion
log!("[TEST] Testing item insertion");
db.insert_item_by_url(test_url, &test_item).await.unwrap(); db.insert_item_by_url(test_url, &test_item).await.unwrap();
log!("[TEST] Item insertion - PASSED");
// Test retrieval // Test retrieval
log!("[TEST] Testing item retrieval");
let items = db.get_items_by_url(test_url).await.unwrap(); let items = db.get_items_by_url(test_url).await.unwrap();
assert_eq!(items.len(), 1); assert_eq!(items.len(), 1);
let stored_item = &items[0]; let stored_item = &items[0];
assert_eq!(stored_item.name, test_item.name); assert_eq!(stored_item.name, test_item.name);
assert_eq!(stored_item.custom_properties.len(), 2); assert_eq!(stored_item.custom_properties.len(), 2);
log!("[TEST] Item retrieval and validation - PASSED");
// Test update // Test update
log!("[TEST] Testing item update");
let mut updated_item = test_item.clone(); let mut updated_item = test_item.clone();
updated_item.name = "Updated Name".into(); updated_item.name = "Updated Name".into();
db.insert_item_by_url(test_url, &updated_item).await.unwrap(); db.insert_item_by_url(test_url, &updated_item)
.await
.unwrap();
// Verify update // Verify update
let items = db.get_items_by_url(test_url).await.unwrap(); let items = db.get_items_by_url(test_url).await.unwrap();
assert_eq!(items[0].name, "Updated Name"); assert_eq!(items[0].name, "Updated Name");
log!("[TEST] Item update - PASSED");
// Test deletion // Test deletion
db.delete_item_by_url(test_url, &test_item.id).await.unwrap(); log!("[TEST] Testing item deletion");
db.delete_item_by_url(test_url, &test_item.id)
.await
.unwrap();
let items = db.get_items_by_url(test_url).await.unwrap(); let items = db.get_items_by_url(test_url).await.unwrap();
assert!(items.is_empty()); assert!(items.is_empty());
log!("[TEST] Item deletion - PASSED");
log!("[TEST] test_full_item_lifecycle completed successfully");
} }
//URL Management Tests //URL Management Tests
#[tokio::test] #[tokio::test]
async fn test_url_management() { async fn test_url_management() {
log!("[TEST] Starting test_url_management");
let db = create_test_db().await; let db = create_test_db().await;
let test_url = "https://test.com"; let test_url = "https://test.com";
// Test URL creation // Test URL creation
log!("[TEST] Testing URL creation");
let url_id = db.insert_url(test_url).await.unwrap(); let url_id = db.insert_url(test_url).await.unwrap();
assert!(url_id > 0); assert!(url_id > 0);
log!("[TEST] URL creation - PASSED");
// Test duplicate URL handling // Test duplicate URL handling
log!("[TEST] Testing duplicate URL handling");
let duplicate_id = db.insert_url(test_url).await.unwrap(); let duplicate_id = db.insert_url(test_url).await.unwrap();
assert_eq!(url_id, duplicate_id); assert_eq!(url_id, duplicate_id);
log!("[TEST] Duplicate URL handling - PASSED");
// Test URL retrieval // Test URL retrieval
log!("[TEST] Testing URL retrieval");
let conn = db.conn.lock().await; let conn = db.conn.lock().await;
let stored_url: String = conn.query_row( let stored_url: String = conn
"SELECT url FROM urls WHERE id = ?", .query_row("SELECT url FROM urls WHERE id = ?", [url_id], |row| {
[url_id], row.get(0)
|row| row.get(0) })
).unwrap(); .unwrap();
assert_eq!(stored_url, test_url); assert_eq!(stored_url, test_url);
log!("[TEST] URL retrieval - PASSED");
log!("[TEST] test_url_management completed successfully");
} }
//property management tests //property management tests
#[tokio::test] #[tokio::test]
async fn test_property_operations() { async fn test_property_operations() {
log!("[TEST] Starting test_property_operations");
let db = create_test_db().await; let db = create_test_db().await;
let test_url = "https://props.com"; let test_url = "https://props.com";
let test_item = Item { let test_item = Item {
@ -115,43 +151,59 @@ mod db_impl {
wikidata_id: Some("Q123".into()), wikidata_id: Some("Q123".into()),
custom_properties: vec![ custom_properties: vec![
("price".into(), "100".into()), ("price".into(), "100".into()),
("color".into(), "red".into()) ("color".into(), "red".into()),
].into_iter().collect(), ]
}; .into_iter()
.collect(),
};
// Test property creation // Test property creation
log!("[TEST] Testing property creation");
db.insert_item_by_url(test_url, &test_item).await.unwrap(); db.insert_item_by_url(test_url, &test_item).await.unwrap();
// Verify properties stored // Verify properties stored
let items = db.get_items_by_url(test_url).await.unwrap(); let items = db.get_items_by_url(test_url).await.unwrap();
assert_eq!(items[0].custom_properties.len(), 2); assert_eq!(items[0].custom_properties.len(), 2);
log!("[TEST] Property creation - PASSED");
// Test property deletion // Test property deletion
log!("[TEST] Testing property deletion");
db.delete_property_by_url(test_url, "price").await.unwrap(); db.delete_property_by_url(test_url, "price").await.unwrap();
let items = db.get_items_by_url(test_url).await.unwrap(); let items = db.get_items_by_url(test_url).await.unwrap();
assert_eq!(items[0].custom_properties.len(), 1); assert_eq!(items[0].custom_properties.len(), 1);
assert!(!items[0].custom_properties.contains_key("price")); assert!(!items[0].custom_properties.contains_key("price"));
log!("[TEST] Property deletion - PASSED");
log!("[TEST] test_property_operations completed successfully");
} }
//selected properties test //selected properties test
#[tokio::test] #[tokio::test]
async fn test_selected_properties() { async fn test_selected_properties() {
log!("[TEST] Starting test_selected_properties");
let db = create_test_db().await; let db = create_test_db().await;
let test_url = "https://selected.com"; let test_url = "https://selected.com";
// Add test properties // Add test properties
log!("[TEST] Adding selected properties");
db.add_selected_property(test_url, "price").await.unwrap(); db.add_selected_property(test_url, "price").await.unwrap();
db.add_selected_property(test_url, "weight").await.unwrap(); db.add_selected_property(test_url, "weight").await.unwrap();
// Test retrieval // Test retrieval
log!("[TEST] Testing property retrieval");
let props = db.get_selected_properties(test_url).await.unwrap(); let props = db.get_selected_properties(test_url).await.unwrap();
assert_eq!(props.len(), 2); assert_eq!(props.len(), 2);
assert!(props.contains(&"price".to_string())); assert!(props.contains(&"price".to_string()));
assert!(props.contains(&"weight".to_string())); assert!(props.contains(&"weight".to_string()));
log!("[TEST] Property retrieval - PASSED");
// Test duplicate prevention // Test duplicate prevention
log!("[TEST] Testing duplicate prevention");
db.add_selected_property(test_url, "price").await.unwrap(); db.add_selected_property(test_url, "price").await.unwrap();
let props = db.get_selected_properties(test_url).await.unwrap(); let props = db.get_selected_properties(test_url).await.unwrap();
assert_eq!(props.len(), 2); // No duplicate added assert_eq!(props.len(), 2); // No duplicate added
log!("[TEST] Duplicate prevention - PASSED");
log!("[TEST] test_selected_properties completed successfully");
} }
} }
@ -165,7 +217,7 @@ mod db_impl {
// Create a new database connection // Create a new database connection
pub fn new(db_path: &str) -> Result<Self, Error> { pub fn new(db_path: &str) -> Result<Self, Error> {
let conn = Connection::open(db_path)?; let conn = Connection::open(db_path)?;
logging::log!("Database connection established at: {}", db_path); logging::log!("Database connection established at: {}", db_path);
Ok(Database { Ok(Database {
conn: Arc::new(Mutex::new(conn)), conn: Arc::new(Mutex::new(conn)),
}) })
@ -174,15 +226,16 @@ mod db_impl {
// Create the database schema // Create the database schema
pub async fn create_schema(&self) -> Result<(), Error> { pub async fn create_schema(&self) -> Result<(), Error> {
let conn = self.conn.lock().await; let conn = self.conn.lock().await;
// 1. Properties table // 1. Properties table
conn.execute_batch( conn.execute_batch(
"CREATE TABLE IF NOT EXISTS properties ( "CREATE TABLE IF NOT EXISTS properties (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE, name TEXT NOT NULL UNIQUE,
global_usage_count INTEGER DEFAULT 0 global_usage_count INTEGER DEFAULT 0
);" );",
).map_err(|e| { )
.map_err(|e| {
eprintln!("Failed creating properties table: {}", e); eprintln!("Failed creating properties table: {}", e);
e e
})?; })?;
@ -194,7 +247,8 @@ mod db_impl {
url TEXT NOT NULL UNIQUE, url TEXT NOT NULL UNIQUE,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);", );",
).map_err(|e| { )
.map_err(|e| {
eprintln!("Failed creating urls table: {}", e); eprintln!("Failed creating urls table: {}", e);
e e
})?; })?;
@ -209,7 +263,8 @@ mod db_impl {
wikidata_id TEXT, wikidata_id TEXT,
FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE
);", );",
).map_err(|e| { )
.map_err(|e| {
eprintln!("Failed creating items table: {}", e); eprintln!("Failed creating items table: {}", e);
e e
})?; })?;
@ -222,12 +277,13 @@ mod db_impl {
PRIMARY KEY (url_id, property_id), PRIMARY KEY (url_id, property_id),
FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE, FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE,
FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE
);" );",
).map_err(|e| { )
.map_err(|e| {
eprintln!("Failed creating properties table: {}", e); eprintln!("Failed creating properties table: {}", e);
e e
})?; })?;
// 5. Junction table for custom properties // 5. Junction table for custom properties
conn.execute_batch( conn.execute_batch(
"CREATE TABLE IF NOT EXISTS item_properties ( "CREATE TABLE IF NOT EXISTS item_properties (
@ -237,8 +293,9 @@ mod db_impl {
PRIMARY KEY (item_id, property_id), PRIMARY KEY (item_id, property_id),
FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE, FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE
);" );",
).map_err(|e| { )
.map_err(|e| {
eprintln!("Failed creating item_properties table: {}", e); eprintln!("Failed creating item_properties table: {}", e);
e e
})?; })?;
@ -249,19 +306,13 @@ mod db_impl {
pub async fn insert_url(&self, url: &str) -> Result<i64, Error> { pub async fn insert_url(&self, url: &str) -> Result<i64, Error> {
let mut conn = self.conn.lock().await; let mut conn = self.conn.lock().await;
let tx = conn.transaction()?; let tx = conn.transaction()?;
// Use INSERT OR IGNORE to handle duplicates // Use INSERT OR IGNORE to handle duplicates
tx.execute( tx.execute("INSERT OR IGNORE INTO urls (url) VALUES (?)", [url])?;
"INSERT OR IGNORE INTO urls (url) VALUES (?)",
[url]
)?;
// Get the URL ID whether it was inserted or already existed // Get the URL ID whether it was inserted or already existed
let url_id = tx.query_row( let url_id =
"SELECT id FROM urls WHERE url = ?", tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
[url],
|row| row.get(0)
)?;
tx.commit()?; tx.commit()?;
logging::log!("URL inserted: {}", url); logging::log!("URL inserted: {}", url);
@ -277,12 +328,15 @@ mod db_impl {
pub async fn delete_property(&self, property: &str) -> Result<(), Error> { pub async fn delete_property(&self, property: &str) -> Result<(), Error> {
let conn = self.conn.lock().await; let conn = self.conn.lock().await;
let query = format!("UPDATE items SET custom_properties = json_remove(custom_properties, '$.{}')", property); let query = format!(
"UPDATE items SET custom_properties = json_remove(custom_properties, '$.{}')",
property
);
conn.execute(&query, []).map_err(|e| Error::from(e))?; conn.execute(&query, []).map_err(|e| Error::from(e))?;
logging::log!("Property deleted: {}", property); logging::log!("Property deleted: {}", property);
Ok(()) Ok(())
} }
// Retrieve all items from the database // Retrieve all items from the database
pub async fn get_items(&self) -> Result<Vec<DbItem>, Error> { pub async fn get_items(&self) -> Result<Vec<DbItem>, Error> {
let conn = self.conn.lock().await; let conn = self.conn.lock().await;
@ -306,16 +360,15 @@ mod db_impl {
// Retrieve all items from the database for a specific URL // Retrieve all items from the database for a specific URL
pub async fn get_items_by_url(&self, url: &str) -> Result<Vec<Item>, Error> { pub async fn get_items_by_url(&self, url: &str) -> Result<Vec<Item>, Error> {
let conn = self.conn.lock().await; let conn = self.conn.lock().await;
let url_id: Option<i64> = match conn.query_row( let url_id: Option<i64> =
"SELECT id FROM urls WHERE url = ?", match conn.query_row("SELECT id FROM urls WHERE url = ?", &[url], |row| {
&[url], row.get(0)
|row| row.get(0) }) {
) { Ok(id) => Some(id),
Ok(id) => Some(id), Err(rusqlite::Error::QueryReturnedNoRows) => None,
Err(rusqlite::Error::QueryReturnedNoRows) => None, Err(e) => return Err(e),
Err(e) => return Err(e), };
};
let url_id = match url_id { let url_id = match url_id {
Some(id) => id, Some(id) => id,
None => return Ok(Vec::new()), // Return empty list if URL not found None => return Ok(Vec::new()), // Return empty list if URL not found
@ -323,28 +376,27 @@ mod db_impl {
log!("Fetching items for URL '{}' (ID: {})", url, url_id); log!("Fetching items for URL '{}' (ID: {})", url, url_id);
let mut stmt = conn.prepare( let mut stmt = conn.prepare(
"SELECT i.id, i.name, i.description, i.wikidata_id, "SELECT i.id, i.name, i.description, i.wikidata_id,
p.name AS prop_name, ip.value p.name AS prop_name, ip.value
FROM items i FROM items i
LEFT JOIN item_properties ip ON i.id = ip.item_id LEFT JOIN item_properties ip ON i.id = ip.item_id
LEFT JOIN properties p ON ip.property_id = p.id LEFT JOIN properties p ON ip.property_id = p.id
WHERE i.url_id = ?" WHERE i.url_id = ?",
)?; )?;
let mut items: HashMap<String, Item> = HashMap::new(); let mut items: HashMap<String, Item> = HashMap::new();
let rows = stmt.query_map([url_id], |row| { let rows = stmt.query_map([url_id], |row| {
Ok(( Ok((
row.get::<_, String>(0)?, // id row.get::<_, String>(0)?, // id
row.get::<_, String>(1)?, // name row.get::<_, String>(1)?, // name
row.get::<_, String>(2)?, // description row.get::<_, String>(2)?, // description
row.get::<_, Option<String>>(3)?, // wikidata_id row.get::<_, Option<String>>(3)?, // wikidata_id
row.get::<_, Option<String>>(4)?, // prop_name row.get::<_, Option<String>>(4)?, // prop_name
row.get::<_, Option<String>>(5)?, // value row.get::<_, Option<String>>(5)?, // value
)) ))
})?; })?;
for row in rows { for row in rows {
let (id, name, desc, wd_id, prop, val) = row?; let (id, name, desc, wd_id, prop, val) = row?;
let item = items.entry(id.clone()).or_insert(Item { let item = items.entry(id.clone()).or_insert(Item {
@ -354,25 +406,23 @@ mod db_impl {
wikidata_id: wd_id, wikidata_id: wd_id,
custom_properties: HashMap::new(), custom_properties: HashMap::new(),
}); });
if let (Some(p), Some(v)) = (prop, val) { if let (Some(p), Some(v)) = (prop, val) {
item.custom_properties.insert(p, v); item.custom_properties.insert(p, v);
} }
} }
Ok(items.into_values().collect()) Ok(items.into_values().collect())
} }
async fn get_or_create_property( async fn get_or_create_property(
&self, &self,
tx: &mut rusqlite::Transaction<'_>, tx: &mut rusqlite::Transaction<'_>,
prop: &str prop: &str,
) -> Result<i64, Error> { ) -> Result<i64, Error> {
match tx.query_row( match tx.query_row("SELECT id FROM properties WHERE name = ?", [prop], |row| {
"SELECT id FROM properties WHERE name = ?", row.get::<_, i64>(0)
[prop], }) {
|row| row.get::<_, i64>(0)
) {
Ok(id) => Ok(id), Ok(id) => Ok(id),
Err(rusqlite::Error::QueryReturnedNoRows) => { Err(rusqlite::Error::QueryReturnedNoRows) => {
tx.execute("INSERT INTO properties (name) VALUES (?)", [prop])?; tx.execute("INSERT INTO properties (name) VALUES (?)", [prop])?;
@ -385,30 +435,28 @@ mod db_impl {
// Insert a new item into the database for a specific URL // Insert a new item into the database for a specific URL
pub async fn insert_item_by_url(&self, url: &str, item: &Item) -> Result<(), Error> { pub async fn insert_item_by_url(&self, url: &str, item: &Item) -> Result<(), Error> {
log!("[DB] Starting insert for URL: {}, Item: {}", url, item.id); log!("[DB] Starting insert for URL: {}, Item: {}", url, item.id);
// 1. Check database lock acquisition // 1. Check database lock acquisition
let lock_start = std::time::Instant::now(); let lock_start = std::time::Instant::now();
let mut conn = self.conn.lock().await; let mut conn = self.conn.lock().await;
log!("[DB] Lock acquired in {:?}", lock_start.elapsed()); log!("[DB] Lock acquired in {:?}", lock_start.elapsed());
// 2. Transaction handling // 2. Transaction handling
log!("[DB] Starting transaction"); log!("[DB] Starting transaction");
let mut tx = conn.transaction().map_err(|e| { let mut tx = conn.transaction().map_err(|e| {
log!("[DB] Transaction start failed: {:?}", e); log!("[DB] Transaction start failed: {:?}", e);
e e
})?; })?;
// 3. URL handling // 3. URL handling
log!("[DB] Checking URL existence: {}", url); log!("[DB] Checking URL existence: {}", url);
let url_id = match tx.query_row( let url_id = match tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| {
"SELECT id FROM urls WHERE url = ?", row.get::<_, i64>(0)
[url], }) {
|row| row.get::<_, i64>(0)
) {
Ok(id) => { Ok(id) => {
log!("[DB] Found existing URL ID: {}", id); log!("[DB] Found existing URL ID: {}", id);
id id
}, }
Err(rusqlite::Error::QueryReturnedNoRows) => { Err(rusqlite::Error::QueryReturnedNoRows) => {
log!("[DB] Inserting new URL"); log!("[DB] Inserting new URL");
tx.execute("INSERT INTO urls (url) VALUES (?)", [url])?; tx.execute("INSERT INTO urls (url) VALUES (?)", [url])?;
@ -418,7 +466,7 @@ mod db_impl {
} }
Err(e) => return Err(e.into()), Err(e) => return Err(e.into()),
}; };
// 4. Item insertion // 4. Item insertion
log!("[DB] Upserting item"); log!("[DB] Upserting item");
tx.execute( tx.execute(
@ -446,7 +494,7 @@ mod db_impl {
"SELECT p.name, ip.value "SELECT p.name, ip.value
FROM item_properties ip FROM item_properties ip
JOIN properties p ON ip.property_id = p.id JOIN properties p ON ip.property_id = p.id
WHERE ip.item_id = ?" WHERE ip.item_id = ?",
)?; )?;
let mapped_rows = stmt.query_map([&item.id], |row| { let mapped_rows = stmt.query_map([&item.id], |row| {
@ -455,13 +503,18 @@ mod db_impl {
mapped_rows.collect::<Result<HashMap<String, String>, _>>()? mapped_rows.collect::<Result<HashMap<String, String>, _>>()?
}; };
for (prop, value) in &item.custom_properties { for (prop, value) in &item.custom_properties {
// Update existing or insert new // Update existing or insert new
let prop_id = self.get_or_create_property(&mut tx, prop).await?; let prop_id = self.get_or_create_property(&mut tx, prop).await?;
if let Some(existing_value) = existing_props.get(prop) { if let Some(existing_value) = existing_props.get(prop) {
if existing_value != value { if existing_value != value {
log!("[DB] Updating property {} from '{}' to '{}'", prop, existing_value, value); log!(
"[DB] Updating property {} from '{}' to '{}'",
prop,
existing_value,
value
);
tx.execute( tx.execute(
"UPDATE item_properties "UPDATE item_properties
SET value = ? SET value = ?
@ -481,7 +534,8 @@ mod db_impl {
} }
// Remove deleted properties // Remove deleted properties
let current_props: HashSet<&str> = item.custom_properties.keys().map(|s| s.as_str()).collect(); let current_props: HashSet<&str> =
item.custom_properties.keys().map(|s| s.as_str()).collect();
for (existing_prop, _) in existing_props { for (existing_prop, _) in existing_props {
if !current_props.contains(existing_prop.as_str()) { if !current_props.contains(existing_prop.as_str()) {
log!("[DB] Removing deleted property {}", existing_prop); log!("[DB] Removing deleted property {}", existing_prop);
@ -504,18 +558,15 @@ mod db_impl {
let tx = conn.transaction()?; let tx = conn.transaction()?;
// Get URL ID // Get URL ID
let url_id: i64 = tx.query_row( let url_id: i64 =
"SELECT id FROM urls WHERE url = ?", tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
[url],
|row| row.get(0)
)?;
// Delete item and properties // Delete item and properties
tx.execute( tx.execute(
"DELETE FROM items WHERE id = ? AND url_id = ?", "DELETE FROM items WHERE id = ? AND url_id = ?",
[item_id, &url_id.to_string()], [item_id, &url_id.to_string()],
)?; )?;
tx.commit()?; tx.commit()?;
Ok(()) Ok(())
} }
@ -524,14 +575,11 @@ mod db_impl {
pub async fn delete_property_by_url(&self, url: &str, property: &str) -> Result<(), Error> { pub async fn delete_property_by_url(&self, url: &str, property: &str) -> Result<(), Error> {
let mut conn = self.conn.lock().await; let mut conn = self.conn.lock().await;
let tx = conn.transaction()?; let tx = conn.transaction()?;
// Get URL ID // Get URL ID
let url_id: i64 = tx.query_row( let url_id: i64 =
"SELECT id FROM urls WHERE url = ?", tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
[url],
|row| row.get(0)
)?;
// Delete property from all items in this URL // Delete property from all items in this URL
tx.execute( tx.execute(
"DELETE FROM item_properties "DELETE FROM item_properties
@ -543,7 +591,7 @@ mod db_impl {
)", )",
[property, &url_id.to_string()], [property, &url_id.to_string()],
)?; )?;
tx.commit()?; tx.commit()?;
Ok(()) Ok(())
} }
@ -551,25 +599,20 @@ mod db_impl {
pub async fn add_selected_property(&self, url: &str, property: &str) -> Result<(), Error> { pub async fn add_selected_property(&self, url: &str, property: &str) -> Result<(), Error> {
let mut conn = self.conn.lock().await; let mut conn = self.conn.lock().await;
let tx = conn.transaction()?; let tx = conn.transaction()?;
// Insert URL if it does not exists // Insert URL if it does not exists
tx.execute( tx.execute("INSERT OR IGNORE INTO urls (url) VALUES (?)", [url])?;
"INSERT OR IGNORE INTO urls (url) VALUES (?)",
[url]
)?;
// Get URL ID // Get URL ID
let url_id = tx.query_row( let url_id = tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| {
"SELECT id FROM urls WHERE url = ?", row.get::<_, i64>(0)
[url], })?;
|row| row.get::<_, i64>(0)
)?;
// Get/Create property // Get/Create property
let prop_id = match tx.query_row( let prop_id = match tx.query_row(
"SELECT id FROM properties WHERE name = ?", "SELECT id FROM properties WHERE name = ?",
[property], [property],
|row| row.get::<_, i64>(0) |row| row.get::<_, i64>(0),
) { ) {
Ok(id) => id, Ok(id) => id,
Err(_) => { Err(_) => {
@ -577,13 +620,13 @@ mod db_impl {
tx.last_insert_rowid() tx.last_insert_rowid()
} }
}; };
// Insert into selected_properties // Insert into selected_properties
tx.execute( tx.execute(
"INSERT OR IGNORE INTO selected_properties (url_id, property_id) VALUES (?, ?)", "INSERT OR IGNORE INTO selected_properties (url_id, property_id) VALUES (?, ?)",
[url_id, prop_id] [url_id, prop_id],
)?; )?;
tx.commit()?; tx.commit()?;
Ok(()) Ok(())
} }
@ -595,34 +638,42 @@ mod db_impl {
FROM selected_properties sp FROM selected_properties sp
JOIN properties p ON sp.property_id = p.id JOIN properties p ON sp.property_id = p.id
JOIN urls u ON sp.url_id = u.id JOIN urls u ON sp.url_id = u.id
WHERE u.url = ?" WHERE u.url = ?",
)?; )?;
let properties = stmt.query_map([url], |row| row.get(0))?; let properties = stmt.query_map([url], |row| row.get(0))?;
properties.collect() properties.collect()
} }
// function to log database state // function to log database state
pub async fn debug_dump(&self) -> Result<(), Error> { pub async fn debug_dump(&self) -> Result<(), Error> {
let conn = self.conn.lock().await; let conn = self.conn.lock().await;
log!("[DATABASE DEBUG] URLs:"); log!("[DATABASE DEBUG] URLs:");
let mut stmt = conn.prepare("SELECT id, url FROM urls")?; let mut stmt = conn.prepare("SELECT id, url FROM urls")?;
let urls = stmt.query_map([], |row| { let urls = stmt.query_map([], |row| {
Ok(format!("ID: {}, URL: {}", row.get::<_, i64>(0)?, row.get::<_, String>(1)?)) Ok(format!(
"ID: {}, URL: {}",
row.get::<_, i64>(0)?,
row.get::<_, String>(1)?
))
})?; })?;
for url in urls { for url in urls {
log!("[DATABASE DEBUG] {}", url?); log!("[DATABASE DEBUG] {}", url?);
} }
log!("[DATABASE DEBUG] Items:"); log!("[DATABASE DEBUG] Items:");
let mut stmt = conn.prepare("SELECT id, name FROM items")?; let mut stmt = conn.prepare("SELECT id, name FROM items")?;
let items = stmt.query_map([], |row| { let items = stmt.query_map([], |row| {
Ok(format!("ID: {}, Name: '{}'", row.get::<_, String>(0)?, row.get::<_, String>(1)?)) Ok(format!(
"ID: {}, Name: '{}'",
row.get::<_, String>(0)?,
row.get::<_, String>(1)?
))
})?; })?;
for item in items { for item in items {
log!("[DATABASE DEBUG] {}", item?); log!("[DATABASE DEBUG] {}", item?);
} }
Ok(()) Ok(())
} }
} }
@ -638,4 +689,4 @@ mod db_impl {
} }
#[cfg(feature = "ssr")] #[cfg(feature = "ssr")]
pub use db_impl::{Database, DbItem}; pub use db_impl::{Database, DbItem};