Method execute_transaction

src/query/executor.rs:2219–2304

(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
        _query_router: Option<&Arc<QueryRouter>

    }
    
    async fn execute_transaction<T>(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
        _query_router: Option<&Arc<QueryRouter>>,
    ) -> Result<(), PgSqliteError>
    where
        T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send,
    {
        use crate::query::{QueryTypeDetector, QueryType};
        use crate::protocol::TransactionStatus;
        
        // Check if we're in a failed transaction
        let current_status = session.get_transaction_status().await;
        if current_status == TransactionStatus::InFailedTransaction {
            // Only ROLLBACK is allowed in a failed transaction
            if !matches!(QueryTypeDetector::detect_query_type(query), QueryType::Rollback) {
                return Err(PgSqliteError::Protocol(
                    "current transaction is aborted, commands ignored until end of transaction block".to_string()
                ));
            }
        }
        
        match QueryTypeDetector::detect_query_type(query) {
            QueryType::Begin => {
                // Check if we're already in a transaction
                if current_status == TransactionStatus::InTransaction {
                    // PostgreSQL behavior: warn but don't fail
                    tracing::warn!("BEGIN command received while already in transaction");
                    // Send a warning notice
                    use crate::protocol::messages::NoticeResponse;
                    framed.send(BackendMessage::NoticeResponse(NoticeResponse {
                        severity: "WARNING".to_string(),
                        code: "25001".to_string(), // active_sql_transaction
                        message: "there is already a transaction in progress".to_string(),
                        detail: None,
                        hint: None,
                        position: None,
                        where_: None,
                    })).await.map_err(PgSqliteError::Io)?;
                    // Still send CommandComplete, but don't actually execute BEGIN
                    framed.send(BackendMessage::CommandComplete { tag: "BEGIN".to_string() }).await
                        .map_err(PgSqliteError::Io)?;
                } else {
                    tracing::debug!("Executing BEGIN command");
                    db.begin_with_session(&session.id).await?;
                    tracing::debug!("BEGIN executed successfully");
                    // Update transaction status to InTransaction
                    *session.transaction_status.write().await = TransactionStatus::InTransaction;
                    tracing::debug!("Transaction status updated to InTransaction");
                    framed.send(BackendMessage::CommandComplete { tag: "BEGIN".to_string() }).await
                        .map_err(PgSqliteError::Io)?;
                }
            }
            QueryType::Commit => {
                // Can't commit a failed transaction
                if current_status == TransactionStatus::InFailedTransaction {