Method handle_catalog_query

src/catalog/query_interceptor.rs:211–496

(query: &sqlparser::ast::Query, db: Arc<DbHandler>, session: Option<Arc<SessionState>>)

    }

    async fn handle_catalog_query(query: &sqlparser::ast::Query, db: Arc<DbHandler>, session: Option<Arc<SessionState>>) -> Option<DbResponse> {
        debug!("handle_catalog_query called");
        println!("HANDLE_CATALOG_QUERY: called with query");
        // Check if this is a SELECT from pg_catalog tables
        if let SetExpr::Select(select) = &*query.body {
            println!("HANDLE_CATALOG_QUERY: Is SELECT query, from.len()={}, has_joins={}",
                     select.from.len(),
                     !select.from.is_empty() && !select.from[0].joins.is_empty());
            debug!("Is SELECT query, from.len()={}, has_joins={}",
                     select.from.len(),
                     !select.from.is_empty() && !select.from[0].joins.is_empty());
            // Check if this is a JOIN query involving catalog tables
            if !select.from.is_empty() && !select.from[0].joins.is_empty() {
                debug!("Detected as JOIN query");
                println!("HANDLE_CATALOG_QUERY: Detected as JOIN query");

                // Check if this is a JOIN between information_schema tables
                if let TableFactor::Table { name: main_table, .. } = &select.from[0].relation {
                    let main_table_name = main_table.to_string().to_lowercase();
                    println!("HANDLE_CATALOG_QUERY: Main table name: '{}'", main_table_name);

                    // Check if main table and all JOINs are information_schema tables
                    let is_information_schema_join = main_table_name.contains("information_schema") &&
                        select.from[0].joins.iter().all(|j| {
                            if let TableFactor::Table { name: join_table, .. } = &j.relation {
                                let join_table_name = join_table.to_string().to_lowercase();
                                println!("HANDLE_CATALOG_QUERY: Join table name: '{}'", join_table_name);
                                join_table_name.contains("information_schema")
                            } else {
                                false
                            }
                        });

                    println!("HANDLE_CATALOG_QUERY: is_information_schema_join = {}", is_information_schema_join);

                    if is_information_schema_join {
                        debug!("Detected information_schema JOIN query - translating and executing");
                        println!("HANDLE_CATALOG_QUERY: Detected information_schema JOIN query");

                        // Information_schema tables exist as views with underscores, not dots
                        // e.g., information_schema_table_constraints instead of information_schema.table_constraints
                        // We need to translate the query to use the correct view names
                        if let Some(ref session) = session {
                            let session_id = session.id;
                            let mut query_str = query.to_string();

                            // Replace information_schema.table_name with information_schema_table_name
                            query_str = query_str.replace("information_schema.table_constraints", "information_schema_table_constraints");
                            query_str = query_str.replace("information_schema.key_column_usage", "information_schema_key_column_usage");
                            query_str = query_str.replace("information_schema.referential_constraints", "information_schema_referential_constraints");
                            query_str = query_str.replace("information_schema.columns", "information_schema_columns");
                            query_str = query_str.replace("information_schema.tables", "information_schema_tables");
                            query_str = query_str.replace("information_schema.schemata", "information_schema_schemata");

                            println!("HANDLE_CATALOG_QUERY: Translated query: {}", query_str);

                            match db.connection_manager().execute_with_session(&session_id, |conn| {
                                debug!("Executing translated information_schema JOIN query: {}", query_str);