Method execute_dml

src/query/executor.rs:1523–1676

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

    }
    
    async fn execute_dml<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,
    {
        // SQLAlchemy manages transactions explicitly - don't start implicit transactions
        // This was interfering with SQLAlchemy's unit-of-work dirty detection
        
        debug!("execute_dml called with query: {}", query);
        
        // Check for RETURNING clause
        if ReturningTranslator::has_returning_clause(query) {
            debug!("Query has RETURNING clause, using execute_dml_with_returning: {}", query);
            return Self::execute_dml_with_returning(framed, db, session, query, query_router).await;
        } else {
            debug!("Query does NOT have RETURNING clause: {}", query);
        }
        
        // Validate numeric constraints for INSERT/UPDATE before execution
        use crate::query::{QueryTypeDetector, QueryType};
        use crate::validator::NumericValidator;
        
        // Validate before executing - do all database work before any await
        let validation_error = match QueryTypeDetector::detect_query_type(query) {
            QueryType::Insert => {
                if let Some(table_name) = extract_table_name_from_insert(query) {
                    // Validate numeric constraints using session connection
                    match db.with_session_connection(&session.id, |conn| {
                        match NumericValidator::validate_insert(conn, query, &table_name) {
                            Ok(()) => Ok(()),
                            Err(crate::error::PgError::NumericValueOutOfRange { .. }) => {
                                Err(rusqlite::Error::SqliteFailure(
                                    rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                                    Some("NUMERIC_VALUE_OUT_OF_RANGE".to_string())
                                ))
                            },
                            Err(e) => Err(rusqlite::Error::SqliteFailure(
                                rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                                Some(format!("Numeric validation failed: {e}"))
                            ))
                        }
                    }).await {
                        Ok(()) => None,
                        Err(PgSqliteError::Sqlite(rusqlite::Error::SqliteFailure(_, Some(msg)))) if msg == "NUMERIC_VALUE_OUT_OF_RANGE" => {
                            // Create a numeric value out of range error
                            Some(PgSqliteError::Validation(crate::error::PgError::NumericValueOutOfRange {
                                type_name: "numeric".to_string(),
                                column_name: String::new(),
                                value: String::new(),
                            }))
                        },
                        Err(e) => Some(e),
                    }