herocode/db
13
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

fix: Use incremental ID

Browse Source
This commit is contained in:
Mahmoud Emad
2025-05-17 13:46:16 +03:00
parent a676854251
commit 57f59da43e
10 changed files with 519 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
heromodels/examples/basic_user_example.rs
View File

@@ -67,26 +67,18 @@ fn main() {
.is_active(false)
.build();
// Save all users to database and get their assigned IDs
let user1_id = db.collection().expect("can open user collection").set(&user1).expect("can set user");
let user2_id = db.collection().expect("can open user collection").set(&user2).expect("can set user");
let user3_id = db.collection().expect("can open user collection").set(&user3).expect("can set user");
let user4_id = db.collection().expect("can open user collection").set(&user4).expect("can set user");
// Save all users to database and get their assigned IDs and updated models
let (user1_id, db_user1) = db.collection().expect("can open user collection").set(&user1).expect("can set user");
let (user2_id, db_user2) = db.collection().expect("can open user collection").set(&user2).expect("can set user");
let (user3_id, db_user3) = db.collection().expect("can open user collection").set(&user3).expect("can set user");
let (user4_id, db_user4) = db.collection().expect("can open user collection").set(&user4).expect("can set user");
println!("User 1 assigned ID: {}", user1_id);
println!("User 2 assigned ID: {}", user2_id);
println!("User 3 assigned ID: {}", user3_id);
println!("User 4 assigned ID: {}", user4_id);
// Retrieve all users from database using the assigned IDs
let db_user1 = db.collection::<User>().expect("can open user collection")
.get_by_id(user1_id).expect("can load user").expect("user should exist");
let db_user2 = db.collection::<User>().expect("can open user collection")
.get_by_id(user2_id).expect("can load user").expect("user should exist");
let db_user3 = db.collection::<User>().expect("can open user collection")
.get_by_id(user3_id).expect("can load user").expect("user should exist");
let db_user4 = db.collection::<User>().expect("can open user collection")
.get_by_id(user4_id).expect("can load user").expect("user should exist");
// We already have the updated models from the set method, so we don't need to retrieve them again
// Print all users retrieved from database
println!("\n--- Users Retrieved from Database ---");
@@ -125,7 +117,7 @@ fn main() {
.expect("can load stored users");
assert_eq!(active_users.len(), 2);
for (i, active_user) in active_users.iter().enumerate() {
for (_i, active_user) in active_users.iter().enumerate() {
print_user_details(active_user);
}
@@ -147,7 +139,7 @@ fn main() {
println!(" a. Remaining Active Users:");
assert_eq!(active_users.len(), 1);
for (i, active_user) in active_users.iter().enumerate() {
for (_i, active_user) in active_users.iter().enumerate() {
print_user_details(active_user);
}
@@ -160,7 +152,7 @@ fn main() {
println!(" b. Inactive Users:");
assert_eq!(inactive_users.len(), 2);
for (i, inactive_user) in inactive_users.iter().enumerate() {
for (_i, inactive_user) in inactive_users.iter().enumerate() {
print_user_details(inactive_user);
}
@@ -177,22 +169,14 @@ fn main() {
.content("This is a comment on the user")
.build();
// Save the comment and get its assigned ID
let comment_id = db.collection()
// Save the comment and get its assigned ID and updated model
let (comment_id, db_comment) = db.collection()
.expect("can open comment collection")
.set(&comment)
.expect("can set comment");
println!("Comment assigned ID: {}", comment_id);
// 2. Retrieve the comment from database using the assigned ID
let db_comment = db
.collection::<Comment>()
.expect("can open comment collection")
.get_by_id(comment_id)
.expect("can load comment")
.expect("comment should exist");
println!(" a. Comment Retrieved from Database:");
print_comment_details(&db_comment);
@@ -201,19 +185,12 @@ fn main() {
let mut updated_user = db_user1.clone();
updated_user.base_data.add_comment(db_comment.get_id());
db.collection::<User>()
// Save the updated user and get the new version
let (_, user_with_comment) = db.collection::<User>()
.expect("can open user collection")
.set(&updated_user)
.expect("can set updated user");
// 4. Retrieve the updated user
let user_with_comment = db
.collection::<User>()
.expect("can open user collection")
.get_by_id(updated_user.get_id())
.expect("can load user")
.expect("user should exist");
println!(" a. User with Associated Comment:");
print_user_details(&user_with_comment);

12
heromodels/examples/calendar_example/main.rs
View File

@@ -57,16 +57,16 @@ fn main() {
.add_event(event1.clone())
.add_event(event2.clone());
// Create a calendar with explicit ID
let calendar2 = Calendar::new(Some(2), "Personal Calendar")
// Create a calendar with auto-generated ID (explicit IDs are no longer supported)
let calendar2 = Calendar::new(None, "Personal Calendar")
.add_event(event3_for_calendar2.clone());
// --- Store Calendars in DB ---
let cal_collection = db.collection::<Calendar>().expect("can open calendar collection");
cal_collection.set(&calendar1).expect("can set calendar1");
cal_collection.set(&calendar2).expect("can set calendar2");
let (_, calendar1) = cal_collection.set(&calendar1).expect("can set calendar1");
let (_, calendar2) = cal_collection.set(&calendar2).expect("can set calendar2");
println!("Created calendar1 (ID: {}): Name - '{}'", calendar1.get_id(), calendar1.name);
println!("Created calendar2 (ID: {}): Name - '{}'", calendar2.get_id(), calendar2.name);
@@ -98,7 +98,7 @@ fn main() {
println!("Event '{}' rescheduled in stored_calendar1.", rescheduled_event.title);
// --- Store the modified calendar ---
cal_collection.set(&stored_calendar1).expect("can set modified calendar1");
let (_, mut stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set modified calendar1");
let re_retrieved_calendar1_opt = cal_collection.get_by_id(calendar1.get_id()).expect("can try to load modified calendar1");
let re_retrieved_calendar1 = re_retrieved_calendar1_opt.unwrap();
let re_retrieved_event = re_retrieved_calendar1.events.iter().find(|e| e.id == event_id_to_reschedule)
@@ -116,7 +116,7 @@ fn main() {
);
stored_calendar1 = stored_calendar1.add_event(event4_new);
assert_eq!(stored_calendar1.events.len(), 3);
cal_collection.set(&stored_calendar1).expect("can set calendar1 after adding new event");
let (_, stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set calendar1 after adding new event");
println!("Added new event '1-on-1' to stored_calendar1. Total events: {}", stored_calendar1.events.len());
// --- Delete a Calendar ---

26
heromodels/examples/custom_model_example.rs
View File

@@ -1,3 +1,4 @@
use heromodels::db::{Collection, Db};
use heromodels_core::{BaseModelData, Model};
use heromodels_derive::model;
use serde::{Deserialize, Serialize};
@@ -22,16 +23,35 @@ fn main() {
println!("Hero Models - Custom Model Example");
println!("==================================");
// Create a new DB instance, reset before every run
let db_path = "/tmp/ourdb_custom_model_example";
let db = heromodels::db::hero::OurDB::new(db_path, true).expect("Can create DB");
// Example usage of the generated implementation
println!("CustomUser DB Prefix: {}", CustomUser::db_prefix());
let user = CustomUser {
base_data: BaseModelData::new(1),
base_data: BaseModelData::new(), // ID will be auto-generated by OurDB
login: "johndoe".to_string(),
is_active: true,
full_name: "John Doe".to_string(),
};
println!("\nCustomUser ID: {}", user.get_id());
println!("CustomUser DB Keys: {:?}", user.db_keys());
println!("\nBefore saving - CustomUser ID: {}", user.get_id());
println!("Before saving - CustomUser DB Keys: {:?}", user.db_keys());
// Save the model to the database
let collection = db.collection::<CustomUser>().expect("can open user collection");
let (user_id, saved_user) = collection.set(&user).expect("can save user");
println!("\nAfter saving - CustomUser ID: {}", saved_user.get_id());
println!("After saving - CustomUser DB Keys: {:?}", saved_user.db_keys());
println!("Returned ID: {}", user_id);
// Verify that the ID was auto-generated
assert_eq!(saved_user.get_id(), user_id);
assert_ne!(saved_user.get_id(), 0);
println!("\nExample finished. DB stored at {}", db_path);
println!("To clean up, you can manually delete the directory: {}", db_path);
}

41
heromodels/examples/model_macro_example.rs
View File

@@ -1,3 +1,4 @@
use heromodels::db::{Collection, Db};
use heromodels_core::{BaseModelData, Model};
use heromodels_derive::model;
use serde::{Deserialize, Serialize};
@@ -33,26 +34,54 @@ fn main() {
println!("Hero Models - Model Macro Example");
println!("=================================");
// Create a new DB instance, reset before every run
let db_path = "/tmp/ourdb_model_macro_example";
let db = heromodels::db::hero::OurDB::new(db_path, true).expect("Can create DB");
// Example usage of the generated implementations
println!("SimpleUser DB Prefix: {}", SimpleUser::db_prefix());
println!("CustomUser DB Prefix: {}", CustomUser::db_prefix());
let user = SimpleUser {
base_data: BaseModelData::new(1),
base_data: BaseModelData::new(), // ID will be auto-generated by OurDB
login: "johndoe".to_string(),
full_name: "John Doe".to_string(),
};
let custom_user = CustomUser {
base_data: BaseModelData::new(2),
base_data: BaseModelData::new(), // ID will be auto-generated by OurDB
login_name: "janesmith".to_string(),
is_active: true,
full_name: "Jane Smith".to_string(),
};
println!("\nSimpleUser ID: {}", user.get_id());
println!("SimpleUser DB Keys: {:?}", user.db_keys());
println!("\nBefore saving - SimpleUser ID: {}", user.get_id());
println!("Before saving - SimpleUser DB Keys: {:?}", user.db_keys());
println!("\nCustomUser ID: {}", custom_user.get_id());
println!("CustomUser DB Keys: {:?}", custom_user.db_keys());
println!("\nBefore saving - CustomUser ID: {}", custom_user.get_id());
println!("Before saving - CustomUser DB Keys: {:?}", custom_user.db_keys());
// Save the models to the database
let simple_collection = db.collection::<SimpleUser>().expect("can open simple user collection");
let custom_collection = db.collection::<CustomUser>().expect("can open custom user collection");
let (user_id, saved_user) = simple_collection.set(&user).expect("can save simple user");
let (custom_user_id, saved_custom_user) = custom_collection.set(&custom_user).expect("can save custom user");
println!("\nAfter saving - SimpleUser ID: {}", saved_user.get_id());
println!("After saving - SimpleUser DB Keys: {:?}", saved_user.db_keys());
println!("Returned SimpleUser ID: {}", user_id);
println!("\nAfter saving - CustomUser ID: {}", saved_custom_user.get_id());
println!("After saving - CustomUser DB Keys: {:?}", saved_custom_user.db_keys());
println!("Returned CustomUser ID: {}", custom_user_id);
// Verify that the IDs were auto-generated
assert_eq!(saved_user.get_id(), user_id);
assert_ne!(saved_user.get_id(), 0);
assert_eq!(saved_custom_user.get_id(), custom_user_id);
assert_ne!(saved_custom_user.get_id(), 0);
println!("\nExample finished. DB stored at {}", db_path);
println!("To clean up, you can manually delete the directory: {}", db_path);
}

25
heromodels/examples/simple_model_example.rs
View File

@@ -1,3 +1,4 @@
use heromodels::db::{Collection, Db};
use heromodels_core::{BaseModelData, Model};
use heromodels_derive::model;
use serde::{Deserialize, Serialize};
@@ -15,16 +16,36 @@ fn main() {
println!("Hero Models - Simple Model Example");
println!("==================================");
// Create a new DB instance, reset before every run
let db_path = "/tmp/ourdb_simple_model_example";
let db = heromodels::db::hero::OurDB::new(db_path, true).expect("Can create DB");
// Example usage of the generated implementation
println!("SimpleUser DB Prefix: {}", SimpleUser::db_prefix());
// Create a new user with ID 0 (will be auto-generated when saved)
let user = SimpleUser {
base_data: BaseModelData::new(),
login: "johndoe".to_string(),
full_name: "John Doe".to_string(),
};
println!("\nSimpleUser ID: {}", user.get_id());
println!("SimpleUser DB Keys: {:?}", user.db_keys());
println!("\nBefore saving - SimpleUser ID: {}", user.get_id());
println!("Before saving - SimpleUser DB Keys: {:?}", user.db_keys());
// Save the user to the database
let collection = db.collection::<SimpleUser>().expect("can open user collection");
let (user_id, saved_user) = collection.set(&user).expect("can save user");
println!("\nAfter saving - SimpleUser ID: {}", saved_user.get_id());
println!("After saving - SimpleUser DB Keys: {:?}", saved_user.db_keys());
println!("Returned ID: {}", user_id);
// Verify that the ID was auto-generated
assert_eq!(saved_user.get_id(), user_id);
assert_ne!(saved_user.get_id(), 0);
println!("\nExample finished. DB stored at {}", db_path);
println!("To clean up, you can manually delete the directory: {}", db_path);
}