141 lines
4.5 KiB
Rust
141 lines
4.5 KiB
Rust
use heromodels::db::{Collection, Db};
|
|
use heromodels::models::userexample::user::user_index::{is_active, username};
|
|
use heromodels::models::{Comment, User};
|
|
use heromodels_core::Model;
|
|
|
|
fn main() {
|
|
let index_db = tst::TST::new("/tmp/ourdb/tst", true).expect("can create index DB");
|
|
let data_db = ourdb::OurDB::new(ourdb::OurDBConfig {
|
|
incremental_mode: false,
|
|
path: "/tmp/ourdb/ourdb".into(),
|
|
file_size: None,
|
|
keysize: None,
|
|
reset: Some(true),
|
|
})
|
|
.expect("can create data DB");
|
|
let db = heromodels::db::hero::OurDB::new(index_db, data_db);
|
|
|
|
println!("Hero Models - Basic Usage Example");
|
|
println!("================================");
|
|
|
|
// Create a new user using the fluent interface
|
|
let user = User::new(1)
|
|
.username("johndoe")
|
|
.email("john.doe@example.com")
|
|
.full_name("John Doe")
|
|
.is_active(false)
|
|
.build();
|
|
let user2 = User::new(2)
|
|
.username("janesmith")
|
|
.email("jane.smith@example.com")
|
|
.full_name("Jane Smith")
|
|
.is_active(true)
|
|
.build();
|
|
let user3 = User::new(3)
|
|
.username("willism")
|
|
.email("willis.masters@example.com")
|
|
.full_name("Willis Masters")
|
|
.is_active(true)
|
|
.build();
|
|
let user4 = User::new(4)
|
|
.username("carrols")
|
|
.email("carrol.smith@example.com")
|
|
.full_name("Carrol Smith")
|
|
.is_active(false)
|
|
.build();
|
|
|
|
db.collection()
|
|
.expect("can open user collection")
|
|
.set(&user)
|
|
.expect("can set user");
|
|
db.collection()
|
|
.expect("can open user collection")
|
|
.set(&user2)
|
|
.expect("can set user");
|
|
db.collection()
|
|
.expect("can open user collection")
|
|
.set(&user3)
|
|
.expect("can set user");
|
|
db.collection()
|
|
.expect("can open user collection")
|
|
.set(&user4)
|
|
.expect("can set user");
|
|
|
|
// Perform an indexed lookup on the Username
|
|
let stored_users = db
|
|
.collection::<User>()
|
|
.expect("can open user collection")
|
|
.get::<username, _>("johndoe")
|
|
.expect("can load stored user");
|
|
|
|
assert_eq!(stored_users.len(), 1);
|
|
let stored_user = &stored_users[0];
|
|
|
|
assert_eq!(user.username, stored_user.username);
|
|
assert_eq!(user.email, stored_user.email);
|
|
assert_eq!(user.is_active, stored_user.is_active);
|
|
assert_eq!(user.full_name, stored_user.full_name);
|
|
|
|
// Load all active users using the IsActive field index
|
|
// TODO: expand Index type so it defines the type of the key
|
|
let active_users = db
|
|
.collection::<User>()
|
|
.expect("can open user collection")
|
|
.get::<is_active, _>(&true)
|
|
.expect("can load stored users");
|
|
// We should have 2 active users
|
|
assert_eq!(active_users.len(), 2);
|
|
|
|
// Now remove a user
|
|
db.collection::<User>()
|
|
.expect("can open user collection")
|
|
.delete_by_id(active_users[0].get_id())
|
|
.expect("can delete existing user");
|
|
|
|
// Load the active users again, should be 1 left
|
|
let active_users = db
|
|
.collection::<User>()
|
|
.expect("can open user collection")
|
|
.get::<is_active, _>(&true)
|
|
.expect("can load stored users");
|
|
assert_eq!(active_users.len(), 1);
|
|
// And verify we still have 2 inactive users
|
|
let inactive_users = db
|
|
.collection::<User>()
|
|
.expect("can open user collection")
|
|
.get::<is_active, _>(&false)
|
|
.expect("can load stored users");
|
|
assert_eq!(inactive_users.len(), 2);
|
|
|
|
println!("Created user: {:?}", user);
|
|
println!("User ID: {}", user.get_id());
|
|
println!("User DB Prefix: {}", User::db_prefix());
|
|
|
|
// Create a comment for the user
|
|
let comment = Comment::new(5)
|
|
.user_id(1) // commenter's user ID
|
|
.content("This is a comment on the user")
|
|
.build();
|
|
|
|
db.collection()
|
|
.expect("can open commen collection")
|
|
.set(&comment)
|
|
.expect("can set comment");
|
|
|
|
let stored_comment = db
|
|
.collection::<Comment>()
|
|
.expect("can open comment collection")
|
|
.get_by_id(5)
|
|
.expect("can load stored comment");
|
|
|
|
assert!(stored_comment.is_some());
|
|
let stored_comment = stored_comment.unwrap();
|
|
|
|
assert_eq!(comment.get_id(), stored_comment.get_id());
|
|
assert_eq!(comment.content, stored_comment.content);
|
|
|
|
println!("\nCreated comment: {:?}", comment);
|
|
println!("Comment ID: {}", comment.get_id());
|
|
println!("Comment DB Prefix: {}", Comment::db_prefix());
|
|
}
|