Method execute_with_session_mut

src/session/connection_manager.rs:224–257

Execute a function with a mutable connection for a session

(
        &self, 
        session_id: &Uuid, 
        f: F
    )

    
    /// Execute a function with a mutable connection for a session
    pub fn execute_with_session_mut<F, R>(
        &self, 
        session_id: &Uuid, 
        f: F
    ) -> Result<R, PgSqliteError>
    where
        F: FnOnce(&mut Connection) -> Result<R, rusqlite::Error>
    {
        // First try thread-local cache (fast path)
        if let Some(conn_arc) = ThreadLocalConnectionCache::get(session_id) {
            let mut conn = conn_arc.lock();
            return f(&mut conn).map_err(PgSqliteError::Sqlite);
        }
        
        // Fall back to global map (slow path)
        let connections = self.connections.read();
        
        // Get the connection Arc
        let conn_arc = connections.get(session_id)
            .ok_or_else(|| PgSqliteError::Protocol(format!("No connection found for session {session_id}")))?;
        
        // Clone the Arc to avoid holding the read lock
        let conn_arc = conn_arc.clone();
        
        // Drop the read lock early
        drop(connections);
        
        // Cache in thread-local storage for next time
        ThreadLocalConnectionCache::insert(*session_id, conn_arc.clone());
        
        // Now lock the individual connection for mutable access
        let mut conn = conn_arc.lock();
        f(&mut conn).map_err(PgSqliteError::Sqlite)
    }
    
    /// Get the connection Arc for a session (for caching)
    pub fn get_connection_arc(&self, session_id: &Uuid) -> Option<Arc<Mutex<Connection>>> {