Method extract_source_table_column_for_alias

src/query/extended.rs:1035–1107

Try to extract the source table and column for an alias in a simple SELECT e.g., "SELECT test_users.id AS users_id" -> returns ("test_users", "id") e.g., "SELECT id AS event_id FROM test_events" -> returns ("test_events", "id")

(query: &str, alias: &str)

    /// e.g., "SELECT test_users.id AS users_id" -> returns ("test_users", "id")
    /// e.g., "SELECT id AS event_id FROM test_events" -> returns ("test_events", "id")
    fn extract_source_table_column_for_alias(query: &str, alias: &str) -> Option<(String, String)> {
        // This is a simple heuristic for the common case
        // Look for "SELECT <expr> as <alias>" pattern
        info!("extract_source_table_column_for_alias: Looking for alias '{}' in query", alias);
        let query_upper = query.to_uppercase();
        let alias_upper = alias.to_uppercase();
        
        // Find "AS <alias>" in the query
        let as_pattern = format!(" AS {alias_upper}");
        info!("Looking for pattern: '{}'", as_pattern);
        if let Some(as_pos) = query_upper.find(&as_pattern) {
            info!("Found AS pattern at position {}", as_pos);
            // Work backwards to find the start of the expression
            let before_as = &query[..as_pos];
            
            // Find the column expression before AS
            // Handle both "table.column" and "column" patterns
            
            // Get the last token/word before AS (handling commas and spaces)
            let trimmed = before_as.trim_end();
            info!("Text before AS (trimmed): '{}'", trimmed);
            
            // Find where this expression starts (after SELECT or comma)
            let mut expr_start = 0;
            let select_upper = "SELECT ";
            
            // Look for the last comma or SELECT keyword
            if let Some(comma_pos) = trimmed.rfind(',') {
                expr_start = comma_pos + 1;
                info!("Found comma at position {}, expr_start = {}", comma_pos, expr_start);
            } else if let Some(select_pos) = query_upper.find(select_upper) {
                expr_start = select_pos + select_upper.len();
                info!("Found SELECT at position {}, expr_start = {}", select_pos, expr_start);
            }
            
            // Make sure expr_start is within bounds
            if expr_start >= trimmed.len() {
                info!("expr_start {} >= trimmed.len() {}, using 0", expr_start, trimmed.len());
                expr_start = 0;
            }
            
            let expr = trimmed[expr_start..].trim();
            info!("Extracted expression: '{}'", expr);
            
            // Check if it contains a dot (table.column)
            if let Some(dot_pos) = expr.rfind('.') {
                let table_part = expr[..dot_pos].trim();
                let column_part = expr[dot_pos + 1..].trim();
                info!("Found table.column pattern: '{}' . '{}'", table_part, column_part);
                
                // Validate both parts are simple identifiers
                if table_part.chars().all(|c| c.is_alphanumeric() || c == '_') &&
                   column_part.chars().all(|c| c.is_alphanumeric() || c == '_') {
                    info!("Successfully parsed alias '{}' -> table '{}', column '{}'", alias, table_part, column_part);
                    return Some((table_part.to_string(), column_part.to_string()));
                }
            }
            // For simple column references without table prefix