Method execute_with_session

src/session/db_handler.rs:1988–2143

Execute with session-specific connection

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

    
    /// Execute with session-specific connection
    pub async fn execute_with_session(&self, query: &str, session_id: &Uuid) -> Result<DbResponse, PgSqliteError> {
        // Validate SQL security first
        self.validate_sql_security(query)?;
        // Handle COMMENT DDL statements (need mutable connection)
        if CommentDdlHandler::is_comment_ddl(query) {
            return self.connection_manager.execute_with_session_mut(session_id, |conn| {
                match CommentDdlHandler::handle_comment_ddl(conn, query) {
                    Ok(()) => Ok(DbResponse {
                        columns: vec![],
                        rows: vec![],
                        rows_affected: 0,
                    }),
                    Err(PgSqliteError::Sqlite(e)) => Err(e),
                    Err(PgSqliteError::Protocol(msg)) => Err(rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                        Some(msg)
                    )),
                    Err(_) => Err(rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                        Some("Comment operation failed".to_string())
                    )),
                }
            });
        }

        self.connection_manager.execute_with_session(session_id, |conn| {
            // Check if this is a CREATE TABLE statement that needs special handling
            let (processed_query, type_mappings, _array_columns, _enum_columns) =
                if query.trim_start().to_uppercase().starts_with("CREATE TABLE") {
                    debug!("Processing CREATE TABLE statement with translation...");
                    // Use CREATE TABLE translator with full metadata capture
                    use crate::translator::CreateTableTranslator;
                    match CreateTableTranslator::translate_with_connection_full(query, Some(conn)) {
                        Ok(result) => {
                            debug!("CREATE TABLE translated with {} type mappings and {} array columns",
                                result.type_mappings.len(), result.array_columns.len());
                            (result.sql, result.type_mappings, result.array_columns, result.enum_columns)
                        }
                        Err(e) => {
                            return Err(rusqlite::Error::SqliteFailure(
                                rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                                Some(format!("CREATE TABLE translation failed: {}", e))
                            ));
                        }
                    }
                } else {
                    // Process query with fast path optimization for non-CREATE TABLE statements
                    let processed = process_query(query, conn, &self.schema_cache)?;
                    (processed, std::collections::HashMap::new(), Vec::new(), Vec::new())
                };

            let rows_affected = conn.execute(&processed_query, [])?;

            // Handle CREATE TABLE metadata storage and constraints
            if query.trim_start().to_uppercase().starts_with("CREATE TABLE")
                && let Some(table_name) = extract_table_name_from_create(query) {

                // Store type mappings in schema metadata table