Method execute_with_params

src/session/db_handler.rs:473–595

Execute with bound parameters

(
        &self,
        query: &str,
        params: &[Option<Vec<u8>>],
        session_id: &Uuid
    )

    
    /// Execute with bound parameters
    pub async fn execute_with_params(
        &self,
        query: &str,
        params: &[Option<Vec<u8>>],
        session_id: &Uuid
    ) -> Result<DbResponse, PgSqliteError> {
        // Validate SQL security first
        self.validate_sql_security(query)?;
        debug!("execute_with_params called with query: {}", query);
        debug!("execute_with_params params count: {}", params.len());
        let result = self.connection_manager.execute_with_session(session_id, |conn| {
            // Process query with fast path optimization
            let processed_query = process_query(query, conn, &self.schema_cache)?;
            debug!("Processed query: {}", processed_query);
            
            let mut stmt = conn.prepare(&processed_query)?;
            
            // Convert params to rusqlite values
            // For now, be more aggressive about converting to text since most PostgreSQL
            // parameters in text mode should be text-compatible
            let values: Vec<rusqlite::types::Value> = params.iter()
                .map(|p| match p {
                    Some(data) => {
                        match String::from_utf8(data.clone()) {
                            Ok(s) => {
                                // Parameter converted to text
                                rusqlite::types::Value::Text(s)
                            },
                            Err(_e) => {
                                // For psycopg3 in text mode, all parameters should be UTF-8 text
                                // If UTF-8 conversion fails, try to recover by using lossy conversion
                                // UTF-8 conversion failed, trying lossy
                                let lossy_string = String::from_utf8_lossy(data);
                                if !lossy_string.is_empty() {
                                    // Lossy conversion successful
                                    rusqlite::types::Value::Text(lossy_string.into_owned())
                                } else {
                                    // Storing as blob
                                    rusqlite::types::Value::Blob(data.clone())
                                }
                            },
                        }
                    }
                    None => {
                        // Null parameter
                        rusqlite::types::Value::Null
                    },
                })
                .collect();
            
            let query_type = QueryTypeDetector::detect_query_type(query);
            
            let result = match query_type {
                QueryType::Select => {
                    let column_count = stmt.column_count();
                    let mut columns = Vec::with_capacity(column_count);
                    for i in 0..column_count {
                        columns.push(sanitize_column_name(stmt.column_name(i)?).to_string());