rusty-donkey/heave
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: change mutability to ref while loading with filter

Browse Source
This commit is contained in:
davidemazzocchi
2026-02-06 09:50:07 +01:00
parent 5215a3a724
commit 5db868b192
4 changed files with 70 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
01.workspace/heave/examples/using_filters.rs
View File

@@ -120,7 +120,7 @@ fn main() {
// Persist the changes to the database. // Persist the changes to the database.
catalog.persist().unwrap(); catalog.persist().unwrap();
// Create a new catalog to ensure we are loading from the database. // Create a new catalog to ensure we are loading from the database.
let mut new_catalog = Catalog::new(db_path); let new_catalog = Catalog::new(db_path);
// Create a composite filter. // Create a composite filter.
// We are looking for resistors with a value greater than 1000 that are in stock. // We are looking for resistors with a value greater than 1000 that are in stock.
let filter = Filter::new() let filter = Filter::new()

6
01.workspace/heave/examples/working_with_many_types.rs
View File

@@ -134,7 +134,7 @@ fn main() -> Result<(), FailedTo> {
println!("== 2. Loading products using class and subclass filters =="); println!("== 2. Loading products using class and subclass filters ==");
// Load only laptops // Load only laptops
let mut laptop_catalog = Catalog::new(db_path); let laptop_catalog = Catalog::new(db_path);
let laptop_filter = Filter::new() let laptop_filter = Filter::new()
.with_class(Product::class()) .with_class(Product::class())
.with_subclass("laptop"); .with_subclass("laptop");
@@ -162,7 +162,7 @@ fn main() -> Result<(), FailedTo> {
println!("== 3. Loading products using attribute filters =="); println!("== 3. Loading products using attribute filters ==");
// Load expensive products (price > 1000) // Load expensive products (price > 1000)
let mut expensive_catalog = Catalog::new(db_path); let expensive_catalog = Catalog::new(db_path);
let expensive_filter = Filter::new() let expensive_filter = Filter::new()
.with_class(Product::class()) .with_class(Product::class())
.with_unsigned_int("price", Comparison::Greater, 1000); .with_unsigned_int("price", Comparison::Greater, 1000);
@@ -197,7 +197,7 @@ fn main() -> Result<(), FailedTo> {
println!(); println!();
println!("== 4. Loading all product types =="); println!("== 4. Loading all product types ==");
let mut all_products_catalog = Catalog::new(db_path); let all_products_catalog = Catalog::new(db_path);
let all_products_filter = Filter::new().with_class(Product::class()); let all_products_filter = Filter::new().with_class(Product::class());
all_products_catalog.load_by_filter(&all_products_filter)?; all_products_catalog.load_by_filter(&all_products_filter)?;

2
01.workspace/heave/src/imp/catalog_load_by_filter.rs
View File

@@ -28,7 +28,7 @@ impl Catalog {
/// ///
/// Returns `Err(FailedTo::LoadFromDB)` if there is an issue loading entities /// Returns `Err(FailedTo::LoadFromDB)` if there is an issue loading entities
/// from the database based on the provided filter. /// from the database based on the provided filter.
pub fn load_by_filter(&mut self, filter: &Filter) -> Result<(), FailedTo> { pub fn load_by_filter(&self, filter: &Filter) -> Result<(), FailedTo> {
let path = path::Path::new(&self.path); let path = path::Path::new(&self.path);
self.on_items(|items| { self.on_items(|items| {
let entities = let entities =

130
01.workspace/heave/src/tst/catalog_load_by_filter.rs
View File

@@ -40,7 +40,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_bool("in_stock", true); let filter = Filter::new().with_bool("in_stock", true);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -79,7 +79,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_bool("in_stock", false); let filter = Filter::new().with_bool("in_stock", false);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
@@ -118,7 +118,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new(); let filter = Filter::new();
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -146,7 +146,7 @@ mod tests {
}; };
catalog_setup.upsert(item_in_db.clone()).unwrap(); catalog_setup.upsert(item_in_db.clone()).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let item_in_memory = Item { let item_in_memory = Item {
id: "item-1".to_string(), id: "item-1".to_string(),
subclass: Some("subitem".to_string()), subclass: Some("subitem".to_string()),
@@ -168,7 +168,7 @@ mod tests {
// Confirms that the function returns an appropriate error if the database operation fails. // Confirms that the function returns an appropriate error if the database operation fails.
let invalid_path = "target/test_dbs/a_directory_for_lbf_fail"; let invalid_path = "target/test_dbs/a_directory_for_lbf_fail";
std::fs::create_dir_all(invalid_path).unwrap(); std::fs::create_dir_all(invalid_path).unwrap();
let mut catalog = Catalog::new(invalid_path); let catalog = Catalog::new(invalid_path);
let filter = Filter::new(); let filter = Filter::new();
let result = catalog.load_by_filter(&filter); let result = catalog.load_by_filter(&filter);
assert!(result.is_err()); assert!(result.is_err());
@@ -213,7 +213,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::Equal, 10); let filter = Filter::new().with_signed_int("sell_trend", Comparison::Equal, 10);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -260,7 +260,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::Equal, -5); let filter = Filter::new().with_signed_int("sell_trend", Comparison::Equal, -5);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
@@ -307,7 +307,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 5); let filter = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 5);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -355,18 +355,18 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Edge Case 1: Value equal to filter value should not be included. // Edge Case 1: Value equal to filter value should not be included.
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 10); let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 10);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-3").unwrap()); assert!(catalog1.contains_key("item-3").unwrap());
// Edge Case 2: No values greater than filter value. // Edge Case 2: No values greater than filter value.
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 20); let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, 20);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
// Edge Case 3: All values greater than filter value. // Edge Case 3: All values greater than filter value.
let mut catalog3 = Catalog::new(db_path); let catalog3 = Catalog::new(db_path);
let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, -10); let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::Greater, -10);
assert!(catalog3.load_by_filter(&filter3).is_ok()); assert!(catalog3.load_by_filter(&filter3).is_ok());
assert_eq!(catalog3.len().unwrap(), 3); assert_eq!(catalog3.len().unwrap(), 3);
@@ -413,7 +413,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 15); let filter = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 15);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -461,18 +461,18 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Edge Case 1: Value equal to filter value should not be included. // Edge Case 1: Value equal to filter value should not be included.
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 10); let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 10);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-2").unwrap()); assert!(catalog1.contains_key("item-2").unwrap());
// Edge Case 2: No values lesser than filter value. // Edge Case 2: No values lesser than filter value.
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, -5); let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, -5);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
// Edge Case 3: All values lesser than filter value. // Edge Case 3: All values lesser than filter value.
let mut catalog3 = Catalog::new(db_path); let catalog3 = Catalog::new(db_path);
let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 25); let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::Lesser, 25);
assert!(catalog3.load_by_filter(&filter3).is_ok()); assert!(catalog3.load_by_filter(&filter3).is_ok());
assert_eq!(catalog3.len().unwrap(), 3); assert_eq!(catalog3.len().unwrap(), 3);
@@ -519,7 +519,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 10); let filter = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 10);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -567,18 +567,18 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Edge Case 1: Value equal to filter value should be included. // Edge Case 1: Value equal to filter value should be included.
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 20); let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 20);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-3").unwrap()); assert!(catalog1.contains_key("item-3").unwrap());
// Edge Case 2: No values greater than or equal to filter value. // Edge Case 2: No values greater than or equal to filter value.
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 21); let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, 21);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
// Edge Case 3: All values greater than or equal to filter value. // Edge Case 3: All values greater than or equal to filter value.
let mut catalog3 = Catalog::new(db_path); let catalog3 = Catalog::new(db_path);
let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, -5); let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::GreaterOrEqual, -5);
assert!(catalog3.load_by_filter(&filter3).is_ok()); assert!(catalog3.load_by_filter(&filter3).is_ok());
assert_eq!(catalog3.len().unwrap(), 3); assert_eq!(catalog3.len().unwrap(), 3);
@@ -625,7 +625,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, 10); let filter = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, 10);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -673,18 +673,18 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Edge Case 1: Value equal to filter value should be included. // Edge Case 1: Value equal to filter value should be included.
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, -5); let filter1 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, -5);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-2").unwrap()); assert!(catalog1.contains_key("item-2").unwrap());
// Edge Case 2: No values lesser than or equal to filter value. // Edge Case 2: No values lesser than or equal to filter value.
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, -6); let filter2 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, -6);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
// Edge Case 3: All values lesser than or equal to filter value. // Edge Case 3: All values lesser than or equal to filter value.
let mut catalog3 = Catalog::new(db_path); let catalog3 = Catalog::new(db_path);
let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, 20); let filter3 = Filter::new().with_signed_int("sell_trend", Comparison::LesserOrEqual, 20);
assert!(catalog3.load_by_filter(&filter3).is_ok()); assert!(catalog3.load_by_filter(&filter3).is_ok());
assert_eq!(catalog3.len().unwrap(), 3); assert_eq!(catalog3.len().unwrap(), 3);
@@ -732,44 +732,44 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Equal // Equal
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::Equal, 200); let filter = Filter::new().with_unsigned_int("price", Comparison::Equal, 200);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
// Greater // Greater
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::Greater, 200); let filter = Filter::new().with_unsigned_int("price", Comparison::Greater, 200);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-3").unwrap()); assert!(catalog.contains_key("item-3").unwrap());
// Lesser // Lesser
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::Lesser, 200); let filter = Filter::new().with_unsigned_int("price", Comparison::Lesser, 200);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
// GreaterOrEqual // GreaterOrEqual
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::GreaterOrEqual, 200); let filter = Filter::new().with_unsigned_int("price", Comparison::GreaterOrEqual, 200);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
assert!(catalog.contains_key("item-3").unwrap()); assert!(catalog.contains_key("item-3").unwrap());
// LesserOrEqual // LesserOrEqual
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::LesserOrEqual, 200); let filter = Filter::new().with_unsigned_int("price", Comparison::LesserOrEqual, 200);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
// Edge case: No match // Edge case: No match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::Equal, 400); let filter = Filter::new().with_unsigned_int("price", Comparison::Equal, 400);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
// Edge case: All match // Edge case: All match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_unsigned_int("price", Comparison::GreaterOrEqual, 100); let filter = Filter::new().with_unsigned_int("price", Comparison::GreaterOrEqual, 100);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 3); assert_eq!(catalog.len().unwrap(), 3);
@@ -814,24 +814,24 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Exact match // Exact match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item One"); let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item One");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
// Partial match should not work // Partial match should not work
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item"); let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
// Case insensitive match // Case insensitive match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::IsExactly, "item one"); let filter = Filter::new().with_text("name", Comparison::IsExactly, "item one");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
// No match // No match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item Four"); let filter = Filter::new().with_text("name", Comparison::IsExactly, "Item Four");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
@@ -876,33 +876,33 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Starts with "Item" // Starts with "Item"
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::StartsWith, "Item"); let filter = Filter::new().with_text("name", Comparison::StartsWith, "Item");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
// Starts with "I" // Starts with "I"
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::StartsWith, "I"); let filter = Filter::new().with_text("name", Comparison::StartsWith, "I");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
// No match // No match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::StartsWith, "Z"); let filter = Filter::new().with_text("name", Comparison::StartsWith, "Z");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
// Case insensitive // Case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::StartsWith, "item"); let filter = Filter::new().with_text("name", Comparison::StartsWith, "item");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
assert!(catalog.contains_key("item-2").unwrap()); assert!(catalog.contains_key("item-2").unwrap());
// Full string match // Full string match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::StartsWith, "Item One"); let filter = Filter::new().with_text("name", Comparison::StartsWith, "Item One");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
@@ -948,24 +948,24 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Ends with "one" - case insensitive // Ends with "one" - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::EndsWith, "one"); let filter = Filter::new().with_text("name", Comparison::EndsWith, "one");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-1").unwrap()); assert!(catalog.contains_key("item-1").unwrap());
// Ends with "item" - case insensitive // Ends with "item" - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::EndsWith, "item"); let filter = Filter::new().with_text("name", Comparison::EndsWith, "item");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-3").unwrap()); assert!(catalog.contains_key("item-3").unwrap());
// No match // No match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::EndsWith, "Z"); let filter = Filter::new().with_text("name", Comparison::EndsWith, "Z");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
// Full string match - case insensitive // Full string match - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::EndsWith, "item one"); let filter = Filter::new().with_text("name", Comparison::EndsWith, "item one");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
@@ -1011,23 +1011,23 @@ mod tests {
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Contains "item" - case insensitive // Contains "item" - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::Contains, "item"); let filter = Filter::new().with_text("name", Comparison::Contains, "item");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 3); assert_eq!(catalog.len().unwrap(), 3);
// Contains "THE" - case insensitive // Contains "THE" - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::Contains, "THE"); let filter = Filter::new().with_text("name", Comparison::Contains, "THE");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
assert!(catalog.contains_key("item-3").unwrap()); assert!(catalog.contains_key("item-3").unwrap());
// No match // No match
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::Contains, "Z"); let filter = Filter::new().with_text("name", Comparison::Contains, "Z");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert!(catalog.is_empty().unwrap()); assert!(catalog.is_empty().unwrap());
// Full string match - case insensitive // Full string match - case insensitive
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_text("name", Comparison::Contains, "item one"); let filter = Filter::new().with_text("name", Comparison::Contains, "item one");
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 1); assert_eq!(catalog.len().unwrap(), 1);
@@ -1063,7 +1063,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_real("discount", Comparison::Equal, 0.10); let filter = Filter::new().with_real("discount", Comparison::Equal, 0.10);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -1101,7 +1101,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_real("discount", Comparison::Greater, 0.15); let filter = Filter::new().with_real("discount", Comparison::Greater, 0.15);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -1133,12 +1133,12 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_real("discount", Comparison::Greater, 0.10); let filter1 = Filter::new().with_real("discount", Comparison::Greater, 0.10);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-2").unwrap()); assert!(catalog1.contains_key("item-2").unwrap());
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_real("discount", Comparison::Greater, 0.20); let filter2 = Filter::new().with_real("discount", Comparison::Greater, 0.20);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
@@ -1173,7 +1173,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_real("discount", Comparison::Lesser, 0.15); let filter = Filter::new().with_real("discount", Comparison::Lesser, 0.15);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -1205,12 +1205,12 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_real("discount", Comparison::Lesser, 0.20); let filter1 = Filter::new().with_real("discount", Comparison::Lesser, 0.20);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-1").unwrap()); assert!(catalog1.contains_key("item-1").unwrap());
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_real("discount", Comparison::Lesser, 0.10); let filter2 = Filter::new().with_real("discount", Comparison::Lesser, 0.10);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
@@ -1245,7 +1245,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.15); let filter = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.15);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -1277,12 +1277,12 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.20); let filter1 = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.20);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-2").unwrap()); assert!(catalog1.contains_key("item-2").unwrap());
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.21); let filter2 = Filter::new().with_real("discount", Comparison::GreaterOrEqual, 0.21);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
@@ -1317,7 +1317,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.15); let filter = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.15);
assert!(catalog.load_by_filter(&filter).is_ok()); assert!(catalog.load_by_filter(&filter).is_ok());
assert_eq!(catalog.len().unwrap(), 2); assert_eq!(catalog.len().unwrap(), 2);
@@ -1349,12 +1349,12 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.10); let filter1 = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.10);
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 1); assert_eq!(catalog1.len().unwrap(), 1);
assert!(catalog1.contains_key("item-1").unwrap()); assert!(catalog1.contains_key("item-1").unwrap());
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.09); let filter2 = Filter::new().with_real("discount", Comparison::LesserOrEqual, 0.09);
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert!(catalog2.is_empty().unwrap()); assert!(catalog2.is_empty().unwrap());
@@ -1402,7 +1402,7 @@ mod tests {
]; ];
catalog_setup.insert_many(items).unwrap(); catalog_setup.insert_many(items).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
let mut catalog = Catalog::new(db_path); let catalog = Catalog::new(db_path);
let filter = Filter::new() let filter = Filter::new()
.with_unsigned_int("price", Comparison::Equal, 100) .with_unsigned_int("price", Comparison::Equal, 100)
.with_real("discount", Comparison::Equal, 0.10) .with_real("discount", Comparison::Equal, 0.10)
@@ -1475,7 +1475,7 @@ mod tests {
catalog_setup.upsert(another_item).unwrap(); catalog_setup.upsert(another_item).unwrap();
catalog_setup.persist().unwrap(); catalog_setup.persist().unwrap();
// Test 1: Filter by class "item" // Test 1: Filter by class "item"
let mut catalog1 = Catalog::new(db_path); let catalog1 = Catalog::new(db_path);
let filter1 = Filter::new().with_class("item"); let filter1 = Filter::new().with_class("item");
assert!(catalog1.load_by_filter(&filter1).is_ok()); assert!(catalog1.load_by_filter(&filter1).is_ok());
assert_eq!(catalog1.len().unwrap(), 4); assert_eq!(catalog1.len().unwrap(), 4);
@@ -1484,20 +1484,20 @@ mod tests {
assert!(catalog1.contains_key("item-3").unwrap()); assert!(catalog1.contains_key("item-3").unwrap());
assert!(catalog1.contains_key("item-4").unwrap()); assert!(catalog1.contains_key("item-4").unwrap());
// Test 2: Filter by class "another_item" // Test 2: Filter by class "another_item"
let mut catalog2 = Catalog::new(db_path); let catalog2 = Catalog::new(db_path);
let filter2 = Filter::new().with_class("another_item"); let filter2 = Filter::new().with_class("another_item");
assert!(catalog2.load_by_filter(&filter2).is_ok()); assert!(catalog2.load_by_filter(&filter2).is_ok());
assert_eq!(catalog2.len().unwrap(), 1); assert_eq!(catalog2.len().unwrap(), 1);
assert!(catalog2.contains_key("another-1").unwrap()); assert!(catalog2.contains_key("another-1").unwrap());
// Test 3: Filter by class "item" and subclass "sub-a" // Test 3: Filter by class "item" and subclass "sub-a"
let mut catalog3 = Catalog::new(db_path); let catalog3 = Catalog::new(db_path);
let filter3 = Filter::new().with_class("item").with_subclass("sub-a"); let filter3 = Filter::new().with_class("item").with_subclass("sub-a");
assert!(catalog3.load_by_filter(&filter3).is_ok()); assert!(catalog3.load_by_filter(&filter3).is_ok());
assert_eq!(catalog3.len().unwrap(), 2); assert_eq!(catalog3.len().unwrap(), 2);
assert!(catalog3.contains_key("item-1").unwrap()); assert!(catalog3.contains_key("item-1").unwrap());
assert!(catalog3.contains_key("item-3").unwrap()); assert!(catalog3.contains_key("item-3").unwrap());
// Test 4: Filter by class "item" and subclass "subitem" (the default) // Test 4: Filter by class "item" and subclass "subitem" (the default)
let mut catalog4 = Catalog::new(db_path); let catalog4 = Catalog::new(db_path);
let filter4 = Filter::new().with_class("item").with_subclass("subitem"); let filter4 = Filter::new().with_class("item").with_subclass("subitem");
assert!(catalog4.load_by_filter(&filter4).is_ok()); assert!(catalog4.load_by_filter(&filter4).is_ok());
assert_eq!(catalog4.len().unwrap(), 1); assert_eq!(catalog4.len().unwrap(), 1);