Method execute_simple_query_direct

src/optimization/read_only_optimizer.rs:317–398

Execute simple query directly with minimal overhead

(
        &self,
        conn: &Connection,
        query: &str,
        plan: &CachedQueryPlan,
    )

    /// Execute simple query directly with minimal overhead
    fn execute_simple_query_direct(
        &self,
        conn: &Connection,
        query: &str,
        plan: &CachedQueryPlan,
    ) -> Result<Option<DbResponse>, rusqlite::Error> {
        let mut stmt = conn.prepare(query)?;
        let mut rows = Vec::new();

        // Execute query with pre-cached column information
        let result_rows = stmt.query_map([], |row| {
            let mut values = Vec::new();
            for (i, col_type) in plan.column_types.iter().enumerate() {
                match row.get_ref(i)? {
                    rusqlite::types::ValueRef::Null => values.push(None),
                    rusqlite::types::ValueRef::Integer(int_val) => {
                        // Use cached type information for conversion
                        if let Some(pg_type) = col_type {
                            match pg_type.to_lowercase().as_str() {
                                "boolean" | "bool" => {
                                    let bool_str = if int_val == 0 { "f" } else { "t" };
                                    values.push(Some(bool_str.as_bytes().to_vec()));
                                }
                                "date" => {
                                    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));
                                }
                                "time" | "timetz" => {
                                    use crate::types::datetime_utils::format_microseconds_to_time_buf;
                                    let mut buf = vec![0u8; 32];
                                    let len = format_microseconds_to_time_buf(int_val, &mut buf);
                                    buf.truncate(len);
                                    values.push(Some(buf));
                                }
                                "timestamp" | "timestamptz" => {
                                    use crate::types::datetime_utils::format_microseconds_to_timestamp_buf;
                                    let mut buf = vec![0u8; 64];
                                    let len = format_microseconds_to_timestamp_buf(int_val, &mut buf);
                                    buf.truncate(len);
                                    values.push(Some(buf));
                                }
                                _ => {
                                    values.push(Some(int_val.to_string().into_bytes()));
                                }
                            }
                        } else {
                            values.push(Some(int_val.to_string().into_bytes()));
                        }
                    }
                    rusqlite::types::ValueRef::Real(f) => {
                        values.push(Some(f.to_string().into_bytes()));
                    }
                    rusqlite::types::ValueRef::Text(s) => {
                        values.push(Some(s.to_vec()));
                    }