Method execute

src/session/db_handler.rs:1750–1932

Execute without session (compatibility - creates temporary connection)

(&self, query: &str)

    
    /// Execute without session (compatibility - creates temporary connection)
    pub async fn execute(&self, query: &str) -> Result<DbResponse, rusqlite::Error> {
        // For compatibility with tests, use shared connection if available
        // Check if it's any form of memory database (including named shared memory)
        debug!("DbHandler::execute - db_path: {}, query: {}", self.db_path, query);
        if self.db_path == ":memory:" || self.db_path.contains("mode=memory") {
            // For memory databases, we need to use a session connection
            // Create a temporary session for backward compatibility
            let temp_session = Uuid::new_v4();
            if let Err(e) = self.create_session_connection(temp_session).await {
                return Err(rusqlite::Error::SqliteFailure(
                    rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                    Some(format!("Failed to create temporary session: {e}"))
                ));
            }
            
            let result = self.execute_with_session(query, &temp_session).await
                .map_err(|e| match e {
                    PgSqliteError::Sqlite(sqlite_err) => sqlite_err,
                    other => rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                        Some(format!("Execution error: {other}"))
                    )
                })?;
            
            self.remove_session_connection(&temp_session);
            Ok(result)
        } else {
            let mut conn = Self::create_initial_connection(&self.db_path, &Config::load())?;

            // Register functions on the temporary connection
            crate::functions::register_all_functions(&conn)?;

            // Handle COMMENT DDL statements
            if CommentDdlHandler::is_comment_ddl(query) {
                return match CommentDdlHandler::handle_comment_ddl(&mut 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())
                    )),
                };
            }

            // Check if this is a CREATE TABLE statement that needs special handling
            let (processed_query, type_mappings) =
                if query.trim_start().to_uppercase().starts_with("CREATE TABLE") {
                    eprintln!("🔨 Processing CREATE TABLE statement in query_with_session...");
                    // Use CREATE TABLE translator with full metadata capture
                    use crate::translator::CreateTableTranslator;