add data packages and remove empty submodule

packages/data/ourdb/examples/advanced_usage.rs

@@ -0,0 +1,231 @@
+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(())
+}