Method analyze_select_params

src/query/extended.rs:5820–5929

Analyze SELECT query to determine parameter types from WHERE clause

(query: &str, db: &Arc<DbHandler>, session: &Arc<SessionState>)

    /// Analyze SELECT query to determine parameter types from WHERE clause
    async fn analyze_select_params(query: &str, db: &Arc<DbHandler>, session: &Arc<SessionState>) -> Result<Vec<i32>, PgSqliteError> {
        // First, check for explicit parameter casts like $1::int4
        let mut param_types = Vec::new();
        
        // Count parameters and try to determine their types
        for i in 1..=99 {
            let param = format!("${i}");
            if !query.contains(&param) {
                break;
            }
            
            // Check for explicit cast first (e.g., $1::int4)
            let cast_pattern = format!(r"\${i}::\s*(\w+)");
            let cast_regex = regex::Regex::new(&cast_pattern).unwrap();
            let mut found_type = false;
            
            if let Some(captures) = cast_regex.captures(query)
                && let Some(type_match) = captures.get(1) {
                    let cast_type = type_match.as_str();
                    let oid = Self::pg_type_name_to_oid(cast_type);
                    param_types.push(oid);
                    info!("Found explicit cast for parameter {}: {} (OID {})", i, cast_type, oid);
                    found_type = true;
                }
            
            if found_type {
                continue;
            }
            
            // If no explicit cast, try to infer from column comparisons
            // Extract table name from SELECT query (only if needed)
            let table_name = if let Some(name) = extract_table_name_from_select(query) {
                name
            } else {
                // No table found, default to text
                param_types.push(25);
                info!("Could not extract table name for parameter {}, defaulting to text", i);
                continue;
            };
            
            info!("Analyzing SELECT params for table: {}", table_name);
            let query_lower = query.to_lowercase();
            
            // Try to find which column this parameter is compared against
            // Look for patterns like "column = $n" or "column < $n" etc.
            
            // Look for the parameter in the query and find the column it's compared to
            // Use simpler string matching instead of complex regex
            let param_escaped = regex::escape(&param);
            let patterns = vec![
                format!(r"(\w+)\s*=\s*{}", param_escaped),
                format!(r"(\w+)\s*<\s*{}", param_escaped),
                format!(r"(\w+)\s*>\s*{}", param_escaped),
                format!(r"(\w+)\s*<=\s*{}", param_escaped),
                format!(r"(\w+)\s*>=\s*{}", param_escaped),
                format!(r"(\w+)\s*!=\s*{}", param_escaped),
                format!(r"(\w+)\s*<>\s*{}", param_escaped),
            ];