TransactionTask Class Reference

#include "Transaction.h"

Inheritance diagram for TransactionTask:

Public Member Functions
	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
int	TryExecute ()
void	CleanupOnFailure ()

Protected Attributes
std::shared_ptr< TransactionBase >	m_trans

Static Protected Attributes
static std::mutex	_deadlockLock

Friends
template<class T >
class	DatabaseWorkerPool
class	DatabaseWorker
class	TransactionCallback

Additional Inherited Members
Public Attributes inherited from SQLOperation
MySQLConnection *	m_conn {nullptr}

Detailed Description

Low level class

Constructor & Destructor Documentation

TransactionTask()

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

inline

: m_trans(std::move(trans)) { }

~TransactionTask()

TransactionTask::~TransactionTask ( )

overridedefault

Member Function Documentation

CleanupOnFailure()

void TransactionTask::CleanupOnFailure ( )

protected

{
    m_trans->Cleanup();
}

References m_trans.

Referenced by Execute(), and TransactionWithResultTask::Execute().

Execute()

bool TransactionTask::Execute ( )

overrideprotectedvirtual

Implements SQLOperation.

Reimplemented in TransactionWithResultTask.

{
    int errorCode = TryExecute();
 
    if (!errorCode)
        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())
                    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();
 
    return false;
}

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

TryExecute()

int TransactionTask::TryExecute ( )

protected

{
    return m_conn->ExecuteTransaction(m_trans);
}

References MySQLConnection::ExecuteTransaction(), SQLOperation::m_conn, and m_trans.

Referenced by Execute(), and TransactionWithResultTask::Execute().

Friends And Related Function Documentation

DatabaseWorker

friend class DatabaseWorker

friend

DatabaseWorkerPool

template<class T >

friend class DatabaseWorkerPool

friend

TransactionCallback

friend class TransactionCallback

friend

Member Data Documentation

_deadlockLock

std::mutex TransactionTask::_deadlockLock

staticprotected

Referenced by Execute(), and TransactionWithResultTask::Execute().

m_trans

std::shared_ptr<TransactionBase> TransactionTask::m_trans

protected

Referenced by CleanupOnFailure(), and TryExecute().