Method acquire

src/session/pool.rs:279–318

(&self)

    }
    
    pub async fn acquire(&self) -> Result<PooledConnection> {
        let permit = self.semaphore.clone().acquire_owned().await.unwrap();
        
        let pool_conn = {
            let mut conns = self.connections.lock().unwrap();
            let mut stats = self.stats.lock().unwrap();
            
            match conns.pop() {
                Some(mut pc) => {
                    pc.touch(); // Update last_used timestamp
                    stats.idle_connections -= 1;
                    stats.active_connections += 1;
                    Some(pc)
                }
                None => {
                    stats.active_connections += 1;
                    None
                }
            }
        };
        
        let conn = match pool_conn {
            Some(pc) => pc.conn,
            None => {
                // Create new connection if pool is empty
                let new_conn = self.create_connection()?;
                let mut stats = self.stats.lock().unwrap();
                stats.connections_created += 1;
                stats.total_connections += 1;
                new_conn
            }
        };
        
        Ok(PooledConnection {
            conn: Some(conn),
            pool: self.connections.clone(),
            stats: self.stats.clone(),
            _permit: permit,
        })
    }
}

pub struct PooledConnection {