Function query_fast_path

src/query/fast_path.rs:356–484

Fast path SELECT execution that bypasses parsing and rewriting

(
    conn: &Connection,
    query: &str,
    schema_cache: &SchemaCache,
)

/// Fast path SELECT execution that bypasses parsing and rewriting
pub fn query_fast_path(
    conn: &Connection,
    query: &str,
    schema_cache: &SchemaCache,
) -> Result<Option<DbResponse>, rusqlite::Error> {
    // Check if query qualifies for fast path
    if let Some(table_name) = can_use_fast_path(query) {
        // Only handle SELECT queries
        if !matches!(crate::query::QueryTypeDetector::detect_query_type(query), crate::query::QueryType::Select) {
            return Ok(None);
        }
        
        // Check if table has decimal columns
        match table_has_decimal_columns(conn, &table_name, schema_cache) {
            Ok(false) => {
                // No decimal columns, execute directly
                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
                let mut rows = Vec::new();
                let result_rows = stmt.query_map([], |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) => {
                                // Check column type for proper formatting
                                let pg_type = column_types.get(i)
                                    .and_then(|opt| opt.as_ref())
                                    .map(|s| s.to_lowercase())
                                    .unwrap_or_default();
                                
                                if pg_type == "boolean" || pg_type == "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()));