Method query_with_session

src/session/db_handler.rs:1276–1747

Query with session-specific connection

(&self, query: &str, session_id: &Uuid)

    
    /// Query with session-specific connection
    pub async fn query_with_session(&self, query: &str, session_id: &Uuid) -> Result<DbResponse, PgSqliteError> {
        eprintln!("🔍 query_with_session called with query: {}", query);
        // Check if this is a catalog query that should be intercepted
        // We need to do this before applying translations
        let lower_query = query.to_lowercase();

        // Handle special system function queries
        if lower_query.trim() == "select current_user()" {
            return Ok(DbResponse {
                columns: vec!["current_user".to_string()],
                rows: vec![vec![Some("postgres".to_string().into_bytes())]],
                rows_affected: 1,
            });
        }

        // Handle pg_tablespace queries
        if lower_query.contains("pg_tablespace") || lower_query.contains("pg_catalog.pg_tablespace") {
            use crate::catalog::query_interceptor::CatalogInterceptor;
            let parsed_query = sqlparser::parser::Parser::parse_sql(&sqlparser::dialect::PostgreSqlDialect {}, query);
            if let Ok(mut statements) = parsed_query
                && let Some(sqlparser::ast::Statement::Query(query_ast)) = statements.pop()
                    && let Some(select) = query_ast.body.as_select() {
                        return Ok(CatalogInterceptor::handle_pg_tablespace_query(select));
                    }
            // Fallback to empty response if parsing fails
            return Ok(DbResponse {
                columns: vec!["oid".to_string(), "spcname".to_string(), "spcowner".to_string()],
                rows: vec![],
                rows_affected: 0,
            });
        }

        // Handle pg_collation queries
        if lower_query.contains("pg_collation") || lower_query.contains("pg_catalog.pg_collation") {
            use crate::catalog::query_interceptor::CatalogInterceptor;
            let parsed_query = sqlparser::parser::Parser::parse_sql(&sqlparser::dialect::PostgreSqlDialect {}, query);
            if let Ok(mut statements) = parsed_query
                && let Some(sqlparser::ast::Statement::Query(query_ast)) = statements.pop()
                    && let Some(select) = query_ast.body.as_select() {
                        return Ok(CatalogInterceptor::handle_pg_collation_query(select));
                    }
            // Fallback to empty response if parsing fails
            return Ok(DbResponse {
                columns: vec!["oid".to_string(), "collname".to_string()],
                rows: vec![],
                rows_affected: 0,
            });
        }

        // Handle pg_replication_slots queries (always empty - SQLite has no replication)
        if lower_query.contains("pg_replication_slots") || lower_query.contains("pg_catalog.pg_replication_slots") {
            use crate::catalog::query_interceptor::CatalogInterceptor;
            let parsed_query = sqlparser::parser::Parser::parse_sql(&sqlparser::dialect::PostgreSqlDialect {}, query);
            if let Ok(mut statements) = parsed_query
                && let Some(sqlparser::ast::Statement::Query(query_ast)) = statements.pop()
                    && let Some(select) = query_ast.body.as_select() {
                        return Ok(CatalogInterceptor::handle_pg_replication_slots_query(select));
                    }