db/ourdb/examples/advanced_usage.rs

use ourdb::{OurDB, OurDBConfig, OurDBSetArgs};
use std::path::PathBuf;
use std::time::Instant;

fn main() -> Result<(), ourdb::Error> {
    // Create a temporary directory for the database
    let db_path = std::env::temp_dir().join("ourdb_advanced_example");
    std::fs::create_dir_all(&db_path)?;
    
    println!("Creating database at: {}", db_path.display());
    
    // Demonstrate key-value mode (non-incremental)
    key_value_mode_example(&db_path)?;
    
    // Demonstrate incremental mode
    incremental_mode_example(&db_path)?;
    
    // Demonstrate performance benchmarking
    performance_benchmark(&db_path)?;
    
    // Clean up (optional)
    if std::env::var("KEEP_DB").is_err() {
        std::fs::remove_dir_all(&db_path)?;
        println!("Cleaned up database directory");
    } else {
        println!("Database kept at: {}", db_path.display());
    }
    
    Ok(())
}

fn key_value_mode_example(base_path: &PathBuf) -> Result<(), ourdb::Error> {
    println!("\n=== Key-Value Mode Example ===");
    
    let db_path = base_path.join("key_value");
    std::fs::create_dir_all(&db_path)?;
    
    // Create a new database with key-value mode (non-incremental)
    let config = OurDBConfig {
        path: db_path,
        incremental_mode: false,
        file_size: Some(1024 * 1024), // 1MB for testing
        keysize: Some(2),             // Small key size for demonstration
        reset: None,                  // Don't reset existing database
    };
    
    let mut db = OurDB::new(config)?;
    
    // In key-value mode, we must provide IDs explicitly
    let custom_ids = [100, 200, 300, 400, 500];
    
    // Store data with custom IDs
    for (i, &id) in custom_ids.iter().enumerate() {
        let data = format!("Record with custom ID {}", id);
        db.set(OurDBSetArgs { id: Some(id), data: data.as_bytes() })?;
        println!("Stored record {} with custom ID: {}", i+1, id);
    }
    
    // Retrieve data by custom IDs
    for &id in &custom_ids {
        let retrieved = db.get(id)?;
        println!("Retrieved ID {}: {}", id, String::from_utf8_lossy(&retrieved));
    }
    
    // Update and track history
    let id_to_update = custom_ids[2]; // ID 300
    for i in 1..=3 {
        let updated_data = format!("Updated record {} (version {})", id_to_update, i);
        db.set(OurDBSetArgs { id: Some(id_to_update), data: updated_data.as_bytes() })?;
        println!("Updated ID {} (version {})", id_to_update, i);
    }
    
    // Get history for the updated record
    let history = db.get_history(id_to_update, 5)?;
    println!("History for ID {} (most recent first):", id_to_update);
    for (i, entry) in history.iter().enumerate() {
        println!("  Version {}: {}", i, String::from_utf8_lossy(entry));
    }
    
    db.close()?;
    println!("Key-value mode example completed");
    
    Ok(())
}

fn incremental_mode_example(base_path: &PathBuf) -> Result<(), ourdb::Error> {
    println!("\n=== Incremental Mode Example ===");
    
    let db_path = base_path.join("incremental");
    std::fs::create_dir_all(&db_path)?;
    
    // Create a new database with incremental mode
    let config = OurDBConfig {
        path: db_path,
        incremental_mode: true,
        file_size: Some(1024 * 1024), // 1MB for testing
        keysize: Some(3),             // 3-byte keys
        reset: None,                  // Don't reset existing database
    };
    
    let mut db = OurDB::new(config)?;
    
    // In incremental mode, IDs are auto-generated
    let mut assigned_ids = Vec::new();
    
    // Store multiple records and collect assigned IDs
    for i in 1..=5 {
        let data = format!("Auto-increment record {}", i);
        let id = db.set(OurDBSetArgs { id: None, data: data.as_bytes() })?;
        assigned_ids.push(id);
        println!("Stored record {} with auto-assigned ID: {}", i, id);
    }
    
    // Check next ID
    let next_id = db.get_next_id()?;
    println!("Next ID to be assigned: {}", next_id);
    
    // Retrieve all records
    for &id in &assigned_ids {
        let retrieved = db.get(id)?;
        println!("Retrieved ID {}: {}", id, String::from_utf8_lossy(&retrieved));
    }
    
    db.close()?;
    println!("Incremental mode example completed");
    
    Ok(())
}

fn performance_benchmark(base_path: &PathBuf) -> Result<(), ourdb::Error> {
    println!("\n=== Performance Benchmark ===");
    
    let db_path = base_path.join("benchmark");
    std::fs::create_dir_all(&db_path)?;
    
    // Create a new database
    let config = OurDBConfig {
        path: db_path,
        incremental_mode: true,
        file_size: Some(1024 * 1024), // 10MB
        keysize: Some(4),             // 4-byte keys
        reset: None,                  // Don't reset existing database
    };
    
    let mut db = OurDB::new(config)?;
    
    // Number of operations for the benchmark
    let num_operations = 1000;
    let data_size = 100; // bytes per record
    
    // Prepare test data
    let test_data = vec![b'A'; data_size];
    
    // Benchmark write operations
    println!("Benchmarking {} write operations...", num_operations);
    let start = Instant::now();
    
    let mut ids = Vec::with_capacity(num_operations);
    for _ in 0..num_operations {
        let id = db.set(OurDBSetArgs { id: None, data: &test_data })?;
        ids.push(id);
    }
    
    let write_duration = start.elapsed();
    let writes_per_second = num_operations as f64 / write_duration.as_secs_f64();
    println!("Write performance: {:.2} ops/sec ({:.2} ms/op)",
             writes_per_second,
             write_duration.as_secs_f64() * 1000.0 / num_operations as f64);
    
    // Benchmark read operations
    println!("Benchmarking {} read operations...", num_operations);
    let start = Instant::now();
    
    for &id in &ids {
        let _ = db.get(id)?;
    }
    
    let read_duration = start.elapsed();
    let reads_per_second = num_operations as f64 / read_duration.as_secs_f64();
    println!("Read performance: {:.2} ops/sec ({:.2} ms/op)",
             reads_per_second,
             read_duration.as_secs_f64() * 1000.0 / num_operations as f64);
    
    // Benchmark update operations
    println!("Benchmarking {} update operations...", num_operations);
    let start = Instant::now();
    
    for &id in &ids {
        db.set(OurDBSetArgs { id: Some(id), data: &test_data })?;
    }
    
    let update_duration = start.elapsed();
    let updates_per_second = num_operations as f64 / update_duration.as_secs_f64();
    println!("Update performance: {:.2} ops/sec ({:.2} ms/op)",
             updates_per_second,
             update_duration.as_secs_f64() * 1000.0 / num_operations as f64);
    
    db.close()?;
    println!("Performance benchmark completed");
    
    Ok(())
}