Method execute_single_statement

src/query/executor.rs:258–961

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

    }
    
    async fn execute_single_statement<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::protocol::TransactionStatus;
        
        // Check if we're in a failed transaction
        if session.get_transaction_status().await == TransactionStatus::InFailedTransaction {
            // Only ROLLBACK is allowed in a failed transaction
            use crate::query::{QueryTypeDetector, QueryType};
            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()
                ));
            }
        }
        // Preprocess query: rewrite pg_show_all_settings() → pg_settings
        let query = preprocess_query(query);
        let query: &str = query.as_str();

        // Handle set_config() function calls
        if let Some(caps) = SET_CONFIG_PATTERN.captures(query) {
            let param_name = caps[1].to_string();
            let param_value = caps[2].to_string();
            // is_local (caps[3]) is ignored — pgsqlite doesn't support transaction-scoped settings

            debug!("Handling set_config('{}', '{}', ...)", param_name, param_value);

            // Set the parameter in the session
            let mut params = session.parameters.write().await;
            params.insert(param_name.to_uppercase(), param_value.clone());
            drop(params);

            // Send synthetic response: RowDescription + DataRow + CommandComplete
            let field = FieldDescription {
                name: "set_config".to_string(),
                table_oid: 0,
                column_id: 1,
                type_oid: PgType::Text.to_oid(),
                type_size: -1,
                type_modifier: -1,
                format: 0,
            };
            framed.send(BackendMessage::RowDescription(vec![field])).await
                .map_err(PgSqliteError::Io)?;

            let row = vec![Some(param_value.as_bytes().to_vec())];
            framed.send(BackendMessage::DataRow(row)).await
                .map_err(PgSqliteError::Io)?;

            framed.send(BackendMessage::CommandComplete {
                tag: "SELECT 1".to_string()