Function test_connection_handling_overhead

tests/protocol_overhead_analysis.rs:129–208

()

#[tokio::test]
async fn test_connection_handling_overhead() {
    println!("\n=== CONNECTION HANDLING OVERHEAD ===\n");
    
    // Test connection creation overhead
    let iterations = 10;
    
    let start = Instant::now();
    for _ in 0..iterations {
        let _db = DbHandler::new(":memory:").expect("Failed to create database");
    }
    let create_time = start.elapsed() / iterations as u32;
    println!("Database creation overhead: {create_time:?}");
    
    // Test mutex contention with concurrent access
    // Use a temporary file instead of in-memory database for shared access
    let test_id2 = Uuid::new_v4().to_string().replace("-", "");
    let db_path2 = format!("/tmp/pgsqlite_test_concurrent_{test_id2}.db");
    let db = std::sync::Arc::new(DbHandler::new(&db_path2).expect("Failed to create database"));
    
    // Create session for single-threaded test
    let session_id = Uuid::new_v4();
    db.create_session_connection(session_id).await.expect("Failed to create session connection");
    
    db.execute_with_session("CREATE TABLE concurrent_test (id INTEGER PRIMARY KEY, value INTEGER)", &session_id)
        .await
        .expect("Failed to create table");
    
    println!("\nConcurrent access test:");
    
    // Single-threaded baseline
    let start = Instant::now();
    for i in 0..100 {
        db.execute_with_session(&format!("INSERT INTO concurrent_test (value) VALUES ({i})"), &session_id)
            .await
            .expect("Failed to execute");
    }
    let single_time = start.elapsed();
    
    // Multi-threaded test
    let start = Instant::now();
    let mut handles = vec![];
    
    for i in 0..10 {
        let db = Arc::clone(&db);
        let handle = tokio::spawn(async move {
            // Each thread needs its own session
            let thread_session_id = Uuid::new_v4();
            db.create_session_connection(thread_session_id).await.expect("Failed to create session connection");
            
            for j in 0..10 {
                db.execute_with_session(&format!("INSERT INTO concurrent_test (value) VALUES ({})", i * 10 + j), &thread_session_id)
                    .await
                    .expect("Failed to execute");
            }
            
            // Clean up session
            db.remove_session_connection(&thread_session_id);
        });