Function execute_fast_select_with_params

src/query/fast_path.rs:607–723

Execute a fast SELECT query with parameters

(
    conn: &Connection,
    query: &str,
    table_name: &str,
    params: &[rusqlite::types::Value],
    schema_cache: &SchemaCache,
)

/// Execute a fast SELECT query with parameters
fn execute_fast_select_with_params(
    conn: &Connection,
    query: &str,
    table_name: &str,
    params: &[rusqlite::types::Value],
    schema_cache: &SchemaCache,
) -> Result<Option<DbResponse>, rusqlite::Error> {
    let mut stmt = conn.prepare(query)?;
    let column_count = stmt.column_count();
    
    // Get column names
    let mut columns = Vec::new();
    for i in 0..column_count {
        columns.push(sanitize_column_name(stmt.column_name(i)?).to_string());
    }
    
    // Check for boolean columns in the schema using cache
    let mut column_types = Vec::new();
    if let Ok(table_schema) = schema_cache.get_or_load(conn, table_name) {
        for col_name in &columns {
            if let Some(col_info) = table_schema.column_map.get(&col_name.to_lowercase()) {
                column_types.push(Some(col_info.pg_type.clone()));
            } else {
                column_types.push(None);
            }
        }
    } else {
        // Fallback to None for all columns
        column_types.resize(columns.len(), None);
    }
    
    // Get rows - with boolean type conversions, using parameters
    let mut rows = Vec::new();
    let result_rows = stmt.query_map(rusqlite::params_from_iter(params.iter()), |row| {
        let mut values = Vec::new();
        for (i, _) in columns.iter().enumerate().take(column_count) {
            match row.get_ref(i)? {
                ValueRef::Null => values.push(None),
                ValueRef::Integer(int_val) => {
                    // Get the column type
                    let pg_type = column_types.get(i)
                        .and_then(|opt| opt.as_ref())
                        .map(|t| t.to_lowercase());
                    
                    match pg_type.as_deref() {
                        Some("boolean") | Some("bool") => {
                            // Convert SQLite's 0/1 to PostgreSQL's f/t format
                            let bool_str = if int_val == 0 { "f" } else { "t" };
                            values.push(Some(bool_str.as_bytes().to_vec()));
                        },
                        Some("date") => {
                            // Convert INTEGER days to YYYY-MM-DD
                            use crate::types::datetime_utils::format_days_to_date_buf;
                            let mut buf = vec![0u8; 32];
                            let len = format_days_to_date_buf(int_val as i32, &mut buf);
                            buf.truncate(len);
                            values.push(Some(buf));
                        },