Method try_execute_fast_path_with_params

src/session/db_handler.rs:2307–2549

Try fast path execution with parameters

(
        &self,
        query: &str,
        params: &[rusqlite::types::Value],
        session_id: &Uuid,
    )

    /// Try fast path execution with parameters
    pub async fn try_execute_fast_path_with_params(
        &self,
        query: &str,
        params: &[rusqlite::types::Value],
        session_id: &Uuid,
    ) -> Result<Option<DbResponse>, PgSqliteError> {
        
        // Detect query type before the closure
        let query_type = QueryTypeDetector::detect_query_type(query);
        
        // Use the connection manager to get the session connection
        let result = self.connection_manager.execute_with_session(session_id, |conn| {
            // Execute the query directly with rusqlite parameters
            let mut stmt = conn.prepare(query)?;
            
            let response: Result<DbResponse, rusqlite::Error> = match query_type {
                QueryType::Select => {
                    let column_count = stmt.column_count();
                    let mut column_names = Vec::with_capacity(column_count);
                    for i in 0..column_count {
                        column_names.push(sanitize_column_name(stmt.column_name(i).unwrap_or("")).to_string());
                    }
                    
                    // Build datetime column info for conversion
                    let mut datetime_columns = std::collections::HashMap::new();
                    
                    // Try to extract table name from query for schema lookup
                    let table_name = FROM_TABLE_REGEX.as_ref()
                        .ok()
                        .and_then(|regex| regex.captures(query))
                        .map(|captures| captures[1].to_string());
                    
                    
                    // Look up column types for datetime conversion
                    if let Some(ref table) = table_name {
                        for (i, column_name) in column_names.iter().enumerate() {
                            // Handle aliased columns by extracting the base column name
                            let base_column_name = if column_name.contains("_") {
                                // For aliased columns like "users_created_at", try to extract "created_at"
                                if let Some(underscore_pos) = column_name.rfind('_') {
                                    &column_name[underscore_pos + 1..]
                                } else {
                                    column_name
                                }
                            } else {
                                column_name
                            };
                            
                            // Look up schema type
                            let mut schema_stmt = conn.prepare(
                                "SELECT pg_type FROM __pgsqlite_schema WHERE table_name = ?1 AND column_name = ?2"
                            )?;
                            
                            if let Ok(Some(pg_type)) = schema_stmt.query_row([table, base_column_name], |row| {
                                row.get::<_, String>(0)
                            }).optional() {
                                if pg_type == "TIMESTAMP" || pg_type == "TIMESTAMP WITHOUT TIME ZONE" {
                                    datetime_columns.insert(i, "timestamp");