Function test_protocol_overhead_breakdown

tests/protocol_overhead_analysis.rs:8–126

()

#[tokio::test]
async fn test_protocol_overhead_breakdown() {
    println!("\n=== PROTOCOL OVERHEAD BREAKDOWN ===\n");
    
    // Use a temporary file instead of in-memory database
    let test_id = Uuid::new_v4().to_string().replace("-", "");
    let db_path = format!("/tmp/pgsqlite_test_{test_id}.db");
    
    let db = std::sync::Arc::new(DbHandler::new(&db_path).expect("Failed to create database"));
    
    // Create a session for testing
    let session_id = Uuid::new_v4();
    db.create_session_connection(session_id).await.expect("Failed to create session connection");
    
    // Create test table
    db.execute_with_session("CREATE TABLE protocol_test (id INTEGER PRIMARY KEY, name TEXT, value INTEGER)", &session_id)
        .await
        .expect("Failed to create table");
    
    let iterations = 1000;
    
    // Test 1: Direct DbHandler execution (no protocol)
    println!("1. Direct DbHandler execution (no protocol):");
    let start = Instant::now();
    for i in 0..iterations {
        let query = format!("INSERT INTO protocol_test (name, value) VALUES ('direct{i}', {i})");
        db.execute_with_session(&query, &session_id).await.expect("Failed to execute INSERT");
    }
    let direct_time = start.elapsed();
    let direct_avg = direct_time / iterations as u32;
    println!("  Total: {direct_time:?}, Average: {direct_avg:?}");
    
    // Test 2: Measure components of INSERT execution
    println!("\n2. Component timing for single INSERT:");
    
    let test_query = "INSERT INTO protocol_test (name, value) VALUES ('component', 999)";
    
    // Measure fast path detection
    let start = Instant::now();
    for _ in 0..100 {
        let _ = pgsqlite::query::fast_path::can_use_fast_path_enhanced(test_query);
    }
    let fast_path_time = start.elapsed() / 100;
    println!("  Fast path detection: {fast_path_time:?}");
    
    // Measure schema cache lookup
    let start = Instant::now();
    for _ in 0..100 {
        let _ = db.get_table_schema("protocol_test").await;
    }
    let schema_time = start.elapsed() / 100;
    println!("  Schema cache lookup: {schema_time:?}");
    
    // Test 3: Batch execution to identify per-query vs per-connection overhead
    println!("\n3. Batch execution analysis:");
    
    // Execute multiple INSERTs in a loop to simulate batch
    let start = Instant::now();
    for batch in 0..100 {