TransactionBase Class Reference

#include "Transaction.h"

Inheritance diagram for TransactionBase:

Public Member Functions
	TransactionBase ()=default
virtual	~TransactionBase ()
void	Append (std::string_view sql)
template<typename... Args>
void	Append (std::string_view sql, Args &&... args)
std::size_t	GetSize () const

Protected Member Functions
void	AppendPreparedStatement (PreparedStatementBase *statement)
void	Cleanup ()

Protected Attributes
std::vector< SQLElementData >	m_queries

Private Attributes
bool	_cleanedUp {false}

Friends
class	TransactionTask
class	MySQLConnection
template<typename T >
class	DatabaseWorkerPool

Detailed Description

Transactions, high level class.

Constructor & Destructor Documentation

TransactionBase()

TransactionBase::TransactionBase ( )

default

~TransactionBase()

virtual TransactionBase::~TransactionBase ( )

inlinevirtual

{ Cleanup(); }

Member Function Documentation

Append() [1/2]

void TransactionBase::Append

(

std::string_view

sql

)

{
    SQLElementData data = {};
    data.type = SQL_ELEMENT_RAW;
    data.element = std::string(sql);
    m_queries.emplace_back(data);
}

References SQLElementData::element, m_queries, SQL_ELEMENT_RAW, and SQLElementData::type.

Append() [2/2]

template<typename... Args>

void TransactionBase::Append ( std::string_view  sql, Args &&...  args  )

inline

    {
        Append(Acore::StringFormatFmt(sql, std::forward<Args>(args)...));
    }

References Acore::StringFormatFmt().

AppendPreparedStatement()

void TransactionBase::AppendPreparedStatement ( PreparedStatementBase *  statement )

protected

{
    SQLElementData data = {};
    data.type = SQL_ELEMENT_PREPARED;
    data.element = stmt;
    m_queries.emplace_back(data);
}

Referenced by Transaction< T >::Append().

Cleanup()

void TransactionBase::Cleanup ( )

protected

{
    // This might be called by explicit calls to Cleanup or by the auto-destructor
    if (_cleanedUp)
        return;
 
    for (SQLElementData& data : m_queries)
    {
        switch (data.type)
        {
            case SQL_ELEMENT_PREPARED:
            {
                try
                {
                    PreparedStatementBase* stmt = std::get<PreparedStatementBase*>(data.element);
                    ASSERT(stmt);
 
                    delete stmt;
                }
                catch (const std::bad_variant_access& ex)
                {
                    LOG_FATAL("sql.sql", "> PreparedStatementBase not found in SQLElementData. {}", ex.what());
                    ABORT();
                }
            }
            break;
            case SQL_ELEMENT_RAW:
            {
                try
                {
                    std::get<std::string>(data.element).clear();
                }
                catch (const std::bad_variant_access& ex)
                {
                    LOG_FATAL("sql.sql", "> std::string not found in SQLElementData. {}", ex.what());
                    ABORT();
                }
            }
            break;
        }
    }
 
    m_queries.clear();
    _cleanedUp = true;
}

References _cleanedUp, ABORT, ASSERT, LOG_FATAL, m_queries, SQL_ELEMENT_PREPARED, and SQL_ELEMENT_RAW.

GetSize()

std::size_t TransactionBase::GetSize ( ) const

inline

{ return m_queries.size(); }

Friends And Related Function Documentation

DatabaseWorkerPool

template<typename T >

friend class DatabaseWorkerPool

friend

MySQLConnection

friend class MySQLConnection

friend

TransactionTask

friend class TransactionTask

friend

Member Data Documentation

_cleanedUp

bool TransactionBase::_cleanedUp {false}

private

Referenced by Cleanup().

m_queries

std::vector<SQLElementData> TransactionBase::m_queries

protected

Referenced by Append(), Transaction< T >::Append(), and Cleanup().