MySQLPreparedStatement Class Reference

#include "MySQLPreparedStatement.h"

Public Member Functions
	MySQLPreparedStatement (MySQLStmt *stmt, std::string_view queryString)
	~MySQLPreparedStatement ()
void	BindParameters (PreparedStatementBase *stmt)
uint32	GetParameterCount () const

Protected Member Functions
void	SetParameter (const uint8 index, bool value)
void	SetParameter (const uint8 index, std::nullptr_t)
void	SetParameter (const uint8 index, std::string const &value)
void	SetParameter (const uint8 index, std::vector< uint8 > const &value)
template<typename T >
void	SetParameter (const uint8 index, T value)
MySQLStmt *	GetSTMT ()
MySQLBind *	GetBind ()
void	ClearParameters ()
void	AssertValidIndex (const uint8 index)
std::string	getQueryString () const

Protected Attributes
PreparedStatementBase *	m_stmt

Private Member Functions
	MySQLPreparedStatement (MySQLPreparedStatement const &right)=delete
MySQLPreparedStatement &	operator= (MySQLPreparedStatement const &right)=delete

Private Attributes
MySQLStmt *	m_Mstmt
uint32	m_paramCount
std::vector< bool >	m_paramsSet
MySQLBind *	m_bind
std::string	m_queryString {}

Friends
class	MySQLConnection
class	PreparedStatementBase

Detailed Description

Constructor & Destructor Documentation

MySQLPreparedStatement() [1/2]

MySQLPreparedStatement::MySQLPreparedStatement	(	MySQLStmt *	stmt,
		std::string_view	queryString
	)

Initialize variable parameters

"If set to 1, causes mysql_stmt_store_result() to update the metadata MYSQL_FIELD->max_length value."

                                                                                          :
    m_stmt(nullptr),
    m_Mstmt(stmt),
    m_bind(nullptr),
    m_queryString(std::string(queryString))
{
    m_paramCount = mysql_stmt_param_count(stmt);
    m_paramsSet.assign(m_paramCount, false);
    m_bind = new MySQLBind[m_paramCount];
    memset(m_bind, 0, sizeof(MySQLBind) * m_paramCount);
 
    MySQLBool bool_tmp = MySQLBool(1);
    mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bool_tmp);
}

References m_bind, m_paramCount, and m_paramsSet.

~MySQLPreparedStatement()

MySQLPreparedStatement::~MySQLPreparedStatement

(

)

{
    ClearParameters();
    if (m_Mstmt->bind_result_done)
    {
        delete[] m_Mstmt->bind->length;
        delete[] m_Mstmt->bind->is_null;
    }
 
    mysql_stmt_close(m_Mstmt);
    delete[] m_bind;
}

References ClearParameters(), m_bind, and m_Mstmt.

MySQLPreparedStatement() [2/2]

MySQLPreparedStatement::MySQLPreparedStatement ( MySQLPreparedStatement const &  right )

privatedelete

Member Function Documentation

AssertValidIndex()

void MySQLPreparedStatement::AssertValidIndex ( const uint8  index )

protected

{
    ASSERT(index < m_paramCount || ParamenterIndexAssertFail(m_stmt->GetIndex(), index, m_paramCount));
 
    if (m_paramsSet[index])
        LOG_ERROR("sql.sql", "[ERROR] Prepared Statement (id: {}) trying to bind value on already bound index ({}).", m_stmt->GetIndex(), index);
}

References ASSERT, PreparedStatementBase::GetIndex(), LOG_ERROR, m_paramCount, m_paramsSet, m_stmt, and ParamenterIndexAssertFail().

Referenced by SetParameter().

BindParameters()

void MySQLPreparedStatement::BindParameters

(

PreparedStatementBase *

stmt

)

{
    m_stmt = stmt;     // Cross reference them for debug output
 
    uint8 pos = 0;
    for (PreparedStatementData const& data : stmt->GetParameters())
    {
        std::visit([&](auto&& param)
        {
            SetParameter(pos, param);
        }, data.data);
 
        ++pos;
    }
 
#ifdef _DEBUG
    if (pos < m_paramCount)
        LOG_WARN("sql.sql", "[WARNING]: BindParameters() for statement {} did not bind all allocated parameters", stmt->GetIndex());
#endif
}

References PreparedStatementBase::GetIndex(), PreparedStatementBase::GetParameters(), LOG_WARN, m_paramCount, m_stmt, and SetParameter().

Referenced by MySQLConnection::_Query(), and MySQLConnection::Execute().

ClearParameters()

void MySQLPreparedStatement::ClearParameters ( )

protected

{
    for (uint32 i=0; i < m_paramCount; ++i)
    {
        delete m_bind[i].length;
        m_bind[i].length = nullptr;
        delete[] (char*)m_bind[i].buffer;
        m_bind[i].buffer = nullptr;
        m_paramsSet[i] = false;
    }
}

References m_bind, m_paramCount, and m_paramsSet.

Referenced by MySQLConnection::_Query(), MySQLConnection::Execute(), and ~MySQLPreparedStatement().

GetBind()

MySQLBind * MySQLPreparedStatement::GetBind ( )

inlineprotected

{ return m_bind; }

Referenced by MySQLConnection::_Query(), and MySQLConnection::Execute().

GetParameterCount()

uint32 MySQLPreparedStatement::GetParameterCount ( ) const

inline

{ return m_paramCount; }

getQueryString()

std::string MySQLPreparedStatement::getQueryString ( ) const

protected

{
    std::string queryString(m_queryString);
 
    size_t pos = 0;
 
    for (PreparedStatementData const& data : m_stmt->GetParameters())
    {
        pos = queryString.find('?', pos);
 
        std::string replaceStr = std::visit([&](auto&& data)
        {
            return PreparedStatementData::ToString(data);
        }, data.data);
 
        queryString.replace(pos, 1, replaceStr);
        pos += replaceStr.length();
    }
 
    return queryString;
}

References PreparedStatementBase::GetParameters(), m_queryString, m_stmt, and PreparedStatementData::ToString().

Referenced by MySQLConnection::_Query(), and MySQLConnection::Execute().

GetSTMT()

MySQLStmt * MySQLPreparedStatement::GetSTMT ( )

inlineprotected

{ return m_Mstmt; }

Referenced by MySQLConnection::_Query(), MySQLConnection::Execute(), and MySQLConnection::Query().

operator=()

MySQLPreparedStatement & MySQLPreparedStatement::operator= ( MySQLPreparedStatement const &  right )

privatedelete

SetParameter() [1/5]

void MySQLPreparedStatement::SetParameter ( const uint8  index, bool  value  )

protected

{
    SetParameter(index, uint8(value ? 1 : 0));
}

References SetParameter().

Referenced by BindParameters(), and SetParameter().

SetParameter() [2/5]

void MySQLPreparedStatement::SetParameter ( const uint8  index, std::nullptr_t    )

protected

{
    AssertValidIndex(index);
    m_paramsSet[index] = true;
    MYSQL_BIND* param = &m_bind[index];
    param->buffer_type = MYSQL_TYPE_NULL;
    delete[] static_cast<char*>(param->buffer);
    param->buffer = nullptr;
    param->buffer_length = 0;
    param->is_null_value = 1;
    delete param->length;
    param->length = nullptr;
}

References AssertValidIndex(), m_bind, and m_paramsSet.

SetParameter() [3/5]

void MySQLPreparedStatement::SetParameter ( const uint8  index, std::string const &  value  )

protected

{
    AssertValidIndex(index);
    m_paramsSet[index] = true;
    MYSQL_BIND* param = &m_bind[index];
    uint32 len = uint32(value.size());
    param->buffer_type = MYSQL_TYPE_VAR_STRING;
    delete[] static_cast<char*>(param->buffer);
    param->buffer = new char[len];
    param->buffer_length = len;
    param->is_null_value = 0;
    delete param->length;
    param->length = new unsigned long(len);
 
    memcpy(param->buffer, value.c_str(), len);
}

References AssertValidIndex(), m_bind, and m_paramsSet.

SetParameter() [4/5]

void MySQLPreparedStatement::SetParameter ( const uint8  index, std::vector< uint8 > const &  value  )

protected

{
    AssertValidIndex(index);
    m_paramsSet[index] = true;
    MYSQL_BIND* param = &m_bind[index];
    uint32 len = uint32(value.size());
    param->buffer_type = MYSQL_TYPE_BLOB;
    delete[] static_cast<char*>(param->buffer);
    param->buffer = new char[len];
    param->buffer_length = len;
    param->is_null_value = 0;
    delete param->length;
    param->length = new unsigned long(len);
 
    memcpy(param->buffer, value.data(), len);
}

References AssertValidIndex(), m_bind, and m_paramsSet.

SetParameter() [5/5]

template<typename T >

void MySQLPreparedStatement::SetParameter ( const uint8  index, T  value  )

protected

{
    AssertValidIndex(index);
    m_paramsSet[index] = true;
    MYSQL_BIND* param = &m_bind[index];
    uint32 len = uint32(sizeof(T));
    param->buffer_type = MySQLType<T>::value;
    delete[] static_cast<char*>(param->buffer);
    param->buffer = new char[len];
    param->buffer_length = 0;
    param->is_null_value = 0;
    param->length = nullptr; // Only != NULL for strings
    param->is_unsigned = std::is_unsigned_v<T>;
 
    memcpy(param->buffer, &value, len);
}

References AssertValidIndex(), m_bind, and m_paramsSet.

Friends And Related Function Documentation

MySQLConnection

friend class MySQLConnection

friend

PreparedStatementBase

friend class PreparedStatementBase

friend

Member Data Documentation

m_bind

MySQLBind* MySQLPreparedStatement::m_bind

private

Referenced by ClearParameters(), MySQLPreparedStatement(), SetParameter(), and ~MySQLPreparedStatement().

m_Mstmt

MySQLStmt* MySQLPreparedStatement::m_Mstmt

private

Referenced by ~MySQLPreparedStatement().

m_paramCount

uint32 MySQLPreparedStatement::m_paramCount

private

Referenced by AssertValidIndex(), BindParameters(), ClearParameters(), and MySQLPreparedStatement().

m_paramsSet

std::vector<bool> MySQLPreparedStatement::m_paramsSet

private

Referenced by AssertValidIndex(), ClearParameters(), MySQLPreparedStatement(), and SetParameter().

m_queryString

std::string MySQLPreparedStatement::m_queryString {}

private

Referenced by getQueryString().

m_stmt

PreparedStatementBase* MySQLPreparedStatement::m_stmt

protected

Referenced by AssertValidIndex(), BindParameters(), and getQueryString().