Function test_insert_bottleneck_analysis

tests/insert_optimization_test.rs:132–226

()

#[tokio::test]
async fn test_insert_bottleneck_analysis() {
    use pgsqlite::session::DbHandler;
    use std::time::Instant;
    use pgsqlite::query::fast_path::can_use_fast_path_enhanced;

    println!("\n=== INSERT BOTTLENECK ANALYSIS ===");
    
    // Create in-memory database
    let db = DbHandler::new(":memory:").expect("Failed to create database");
    
    // Create a session
    let session_id = Uuid::new_v4();
    db.create_session_connection(session_id).await.expect("Failed to create session connection");

    // Create test table without decimal columns
    db.execute_with_session("CREATE TABLE perf_test (id INTEGER PRIMARY KEY, name TEXT, value INTEGER)", &session_id).await.expect("Failed to create table");
    
    // Warm up the connection and caches
    db.execute_with_session("INSERT INTO perf_test (name, value) VALUES ('warmup', 1)", &session_id).await.expect("Failed to warm up");
    
    let test_query = "INSERT INTO perf_test (name, value) VALUES ('test', 42)";
    
    // Test 1: Fast path detection overhead
    let start = Instant::now();
    for _ in 0..1000 {
        let _ = can_use_fast_path_enhanced(test_query);
    }
    let fast_path_time = start.elapsed();
    println!("Fast path detection (1000x): {:?}, avg: {:?}", fast_path_time, fast_path_time / 1000);
    
    // Test 2: Schema cache lookup overhead
    let start = Instant::now();
    for _ in 0..1000 {
        let _ = db.get_table_schema("perf_test").await;
    }
    let schema_lookup_time = start.elapsed();
    println!("Schema cache lookup (1000x): {:?}, avg: {:?}", schema_lookup_time, schema_lookup_time / 1000);
    
    // Test 3: Single INSERT with timing breakdown
    println!("\nSingle INSERT timing breakdown:");
    
    // Measure total time
    let start_total = Instant::now();
    db.execute_with_session("INSERT INTO perf_test (name, value) VALUES ('single', 100)", &session_id).await.expect("Failed to execute INSERT");
    let total_time = start_total.elapsed();
    println!("Total INSERT time: {total_time:?}");
    
    // Test 4: Batch of INSERTs to see if there's per-operation overhead
    println!("\nBatch INSERT performance:");
    let batch_sizes = [10, 100, 500];
    
    for &batch_size in &batch_sizes {
        let start = Instant::now();
        for i in 0..batch_size {
            let query = format!("INSERT INTO perf_test (name, value) VALUES ('batch{i}', {i})");
            db.execute_with_session(&query, &session_id).await.expect("Failed to execute INSERT");
        }
        let duration = start.elapsed();