Method new_with_config

src/session/pool.rs:106–165

(
        path: &str,
        max_connections: usize,
        max_idle_duration: Duration,
        health_check_interval: Duration,
    )

    }

    pub fn new_with_config(
        path: &str,
        max_connections: usize,
        max_idle_duration: Duration,
        health_check_interval: Duration,
    ) -> Result<Self> {
        let stats = Arc::new(Mutex::new(PoolStats {
            total_connections: 0,
            idle_connections: 0,
            active_connections: 0,
            health_checks_performed: 0,
            connections_created: 0,
            connections_dropped: 0,
            health_check_failures: 0,
        }));

        let pool = SqlitePool {
            path: path.to_string(),
            connections: Arc::new(Mutex::new(Vec::new())),
            semaphore: Arc::new(Semaphore::new(max_connections)),
            max_connections,
            max_idle_duration,
            health_check_interval,
            stats,
        };
        
        // Pre-create initial connections (half of max)
        let initial_connections = (max_connections / 2).max(1);
        let mut conns = pool.connections.lock().unwrap();
        let mut stats = pool.stats.lock().unwrap();
        for _ in 0..initial_connections {
            let conn = pool.create_connection()?;
            conns.push(PoolConnection::new(conn));
            stats.connections_created += 1;
            stats.total_connections += 1;
            stats.idle_connections += 1;
        }
        drop(conns);
        drop(stats);
        
        // Start background health check task only if not in test mode
        #[cfg(not(test))]
        {
            let pool_clone = SqlitePool {
                path: pool.path.clone(),
                connections: pool.connections.clone(),
                semaphore: Arc::new(Semaphore::new(0)), // Not used in background task
                max_connections: pool.max_connections,
                max_idle_duration: pool.max_idle_duration,
                health_check_interval: pool.health_check_interval,
                stats: pool.stats.clone(),
            };
            
            tokio::spawn(async move {
                pool_clone.background_health_check().await;
            });
        }