TransactionWithResultTask Class Reference

#include "Transaction.h"

Inheritance diagram for TransactionWithResultTask:

Public Member Functions
	TransactionWithResultTask (std::shared_ptr< TransactionBase > trans)
TransactionFuture	GetFuture ()
Public Member Functions inherited from TransactionTask
	TransactionTask (std::shared_ptr< TransactionBase > trans)
	~TransactionTask () override=default
Public Member Functions inherited from SQLOperation
	SQLOperation ()=default
virtual	~SQLOperation ()=default
virtual int	call ()
virtual bool	Execute ()=0
virtual void	SetConnection (MySQLConnection *con)

Protected Member Functions
bool	Execute () override
Protected Member Functions inherited from TransactionTask
bool	Execute () override
int	TryExecute ()
void	CleanupOnFailure ()

Protected Attributes
TransactionPromise	m_result
Protected Attributes inherited from TransactionTask
std::shared_ptr< TransactionBase >	m_trans

Additional Inherited Members
Public Attributes inherited from SQLOperation
MySQLConnection *	m_conn {nullptr}
Static Protected Attributes inherited from TransactionTask
static std::mutex	_deadlockLock

Detailed Description

Constructor & Destructor Documentation

TransactionWithResultTask()

TransactionWithResultTask::TransactionWithResultTask ( std::shared_ptr< TransactionBase >  trans )

inline

: TransactionTask(trans) { }

Member Function Documentation

Execute()

bool TransactionWithResultTask::Execute ( )

overrideprotectedvirtual

Reimplemented from TransactionTask.

{
    int errorCode = TryExecute();
    if (!errorCode)
    {
        m_result.set_value(true);
        return true;
    }
 
    if (errorCode == ER_LOCK_DEADLOCK)
    {
        std::ostringstream threadIdStream;
        threadIdStream << std::this_thread::get_id();
        std::string threadId = threadIdStream.str();
 
        {
            // Make sure only 1 async thread retries a transaction so they don't keep dead-locking each other
            std::lock_guard<std::mutex> lock(_deadlockLock);
 
            for (Milliseconds loopDuration{}, startMSTime = GetTimeMS(); loopDuration <= DEADLOCK_MAX_RETRY_TIME_MS; loopDuration = GetMSTimeDiffToNow(startMSTime))
            {
                if (!TryExecute())
                {
                    m_result.set_value(true);
                    return true;
                }
 
                LOG_WARN("sql.sql", "Deadlocked SQL Transaction, retrying. Loop timer: {} ms, Thread Id: {}", loopDuration.count(), threadId);
            }
        }
 
        LOG_ERROR("sql.sql", "Fatal deadlocked SQL Transaction, it will not be retried anymore. Thread Id: {}", threadId);
    }
 
    // Clean up now.
    CleanupOnFailure();
    m_result.set_value(false);
 
    return false;
}

References TransactionTask::_deadlockLock, TransactionTask::CleanupOnFailure(), DEADLOCK_MAX_RETRY_TIME_MS, GetMSTimeDiffToNow(), GetTimeMS(), LOG_ERROR, LOG_WARN, m_result, and TransactionTask::TryExecute().

GetFuture()

TransactionFuture TransactionWithResultTask::GetFuture ( )

inline

{ return m_result.get_future(); }

Referenced by DatabaseWorkerPool< T >::AsyncCommitTransaction().

Member Data Documentation

m_result

TransactionPromise TransactionWithResultTask::m_result

protected

Referenced by Execute().