Method create_connection

src/session/connection_manager.rs:31–90

Create a new connection for a session

(&self, session_id: Uuid)

    
    /// Create a new connection for a session
    pub fn create_connection(&self, session_id: Uuid) -> Result<(), PgSqliteError> {
        let mut connections = self.connections.write();
        
        // Check connection limit
        if connections.len() >= self.config.max_connections {
            return Err(PgSqliteError::Protocol(
                format!("Maximum connection limit ({}) reached", self.config.max_connections)
            ));
        }
        
        // Check if connection already exists
        if connections.contains_key(&session_id) {
            warn!("Connection already exists for session {}", session_id);
            return Ok(());
        }
        
        // Create new connection
        let flags = OpenFlags::SQLITE_OPEN_READ_WRITE 
            | OpenFlags::SQLITE_OPEN_CREATE 
            | OpenFlags::SQLITE_OPEN_FULL_MUTEX
            | OpenFlags::SQLITE_OPEN_URI;
        
        debug!("Creating connection for session {} with path: {}", session_id, self.db_path);
            
        let conn = Connection::open_with_flags(&self.db_path, flags)
            .map_err(PgSqliteError::Sqlite)?;
        
        // Set pragmas
        let pragma_sql = format!(
            "PRAGMA journal_mode = {};
             PRAGMA synchronous = {};
             PRAGMA cache_size = {};
             PRAGMA temp_store = MEMORY;
             PRAGMA mmap_size = {};",
            self.config.pragma_journal_mode,
            self.config.pragma_synchronous,
            self.config.pragma_cache_size,
            self.config.pragma_mmap_size
        );
        conn.execute_batch(&pragma_sql)
            .map_err(PgSqliteError::Sqlite)?;
        
        // Register functions
        crate::functions::register_all_functions(&conn)
            .map_err(PgSqliteError::Sqlite)?;
        
        // Initialize metadata
        crate::metadata::TypeMetadata::init(&conn)
            .map_err(PgSqliteError::Sqlite)?;
        
        let conn_arc = Arc::new(Mutex::new(conn));
        connections.insert(session_id, conn_arc.clone());
        
        // Cache in thread-local storage for fast access
        ThreadLocalConnectionCache::insert(session_id, conn_arc);
        
        info!("Created new connection for session {} (total connections: {})", session_id, connections.len());