PreparedResultSet Class Reference

#include "QueryResult.h"

Public Member Functions
	PreparedResultSet (MySQLStmt *stmt, MySQLResult *result, uint64 rowCount, uint32 fieldCount)
	~PreparedResultSet ()
bool	NextRow ()
uint64	GetRowCount () const
uint32	GetFieldCount () const
Field *	Fetch () const
Field const &	operator[] (std::size_t index) const
template<typename... Ts>
std::tuple< Ts... >	FetchTuple ()
auto	begin ()

Static Public Member Functions
static auto	end ()

Protected Attributes
std::vector< QueryResultFieldMetadata >	m_fieldMetadata
std::vector< Field >	m_rows
uint64	m_rowCount
uint64	m_rowPosition
uint32	m_fieldCount

Private Member Functions
void	CleanUp ()
bool	_NextRow ()
void	AssertRows (std::size_t sizeRows)
	PreparedResultSet (PreparedResultSet const &right)=delete
PreparedResultSet &	operator= (PreparedResultSet const &right)=delete

Private Attributes
MySQLBind *	m_rBind
MySQLStmt *	m_stmt
MySQLResult *	m_metadataResult
	Field metadata, returned by mysql_stmt_result_metadata.

Detailed Description

Constructor & Destructor Documentation

PreparedResultSet() [1/2]

PreparedResultSet::PreparedResultSet	(	MySQLStmt *	stmt,
		MySQLResult *	result,
		uint64	rowCount,
		uint32	fieldCount
	)

Todo:

: remove Field::GetCString and use std::string_view in C++17

All data is buffered, let go of mysql c api structures

                                                                                                             :
    m_rowCount(rowCount),
    m_rowPosition(0),
    m_fieldCount(fieldCount),
    m_rBind(nullptr),
    m_stmt(stmt),
    m_metadataResult(result)
{
    if (!m_metadataResult)
        return;
 
    if (m_stmt->bind_result_done)
    {
        delete[] m_stmt->bind->length;
        delete[] m_stmt->bind->is_null;
    }
 
    m_rBind = new MySQLBind[m_fieldCount];
 
    //- for future readers wondering where this is freed - mysql_stmt_bind_result moves pointers to these
    // from m_rBind to m_stmt->bind and it is later freed by the `if (m_stmt->bind_result_done)` block just above here
    // MYSQL_STMT lifetime is equal to connection lifetime
    MySQLBool* m_isNull = new MySQLBool[m_fieldCount];
    unsigned long* m_length = new unsigned long[m_fieldCount];
 
    memset(m_isNull, 0, sizeof(MySQLBool) * m_fieldCount);
    memset(m_rBind, 0, sizeof(MySQLBind) * m_fieldCount);
    memset(m_length, 0, sizeof(unsigned long) * m_fieldCount);
 
    //- This is where we store the (entire) resultset
    if (mysql_stmt_store_result(m_stmt))
    {
        LOG_WARN("sql.sql", "{}:mysql_stmt_store_result, cannot bind result from MySQL server. Error: {}", __FUNCTION__, mysql_stmt_error(m_stmt));
        delete[] m_rBind;
        delete[] m_isNull;
        delete[] m_length;
        return;
    }
 
    m_rowCount = mysql_stmt_num_rows(m_stmt);
 
    //- This is where we prepare the buffer based on metadata
    MySQLField* field = reinterpret_cast<MySQLField*>(mysql_fetch_fields(m_metadataResult));
    m_fieldMetadata.resize(m_fieldCount);
    std::size_t rowSize = 0;
 
    for (uint32 i = 0; i < m_fieldCount; ++i)
    {
        uint32 size = SizeForType(&field[i]);
        rowSize += size;
 
        InitializeDatabaseFieldMetadata(&m_fieldMetadata[i], &field[i], i);
 
        m_rBind[i].buffer_type = field[i].type;
        m_rBind[i].buffer_length = size;
        m_rBind[i].length = &m_length[i];
        m_rBind[i].is_null = &m_isNull[i];
        m_rBind[i].error = nullptr;
        m_rBind[i].is_unsigned = field[i].flags & UNSIGNED_FLAG;
    }
 
    char* dataBuffer = new char[rowSize * m_rowCount];
    for (uint32 i = 0, offset = 0; i < m_fieldCount; ++i)
    {
        m_rBind[i].buffer = dataBuffer + offset;
        offset += m_rBind[i].buffer_length;
    }
 
    //- This is where we bind the bind the buffer to the statement
    if (mysql_stmt_bind_result(m_stmt, m_rBind))
    {
        LOG_WARN("sql.sql", "{}:mysql_stmt_bind_result, cannot bind result from MySQL server. Error: {}", __FUNCTION__, mysql_stmt_error(m_stmt));
        mysql_stmt_free_result(m_stmt);
        CleanUp();
        delete[] m_isNull;
        delete[] m_length;
        return;
    }
 
    m_rows.resize(uint32(m_rowCount) * m_fieldCount);
 
    while (_NextRow())
    {
        for (uint32 fIndex = 0; fIndex < m_fieldCount; ++fIndex)
        {
            m_rows[uint32(m_rowPosition) * m_fieldCount + fIndex].SetMetadata(&m_fieldMetadata[fIndex]);
 
            unsigned long buffer_length = m_rBind[fIndex].buffer_length;
            unsigned long fetched_length = *m_rBind[fIndex].length;
            if (!*m_rBind[fIndex].is_null)
            {
                void* buffer = m_stmt->bind[fIndex].buffer;
                switch (m_rBind[fIndex].buffer_type)
                {
                case MYSQL_TYPE_TINY_BLOB:
                case MYSQL_TYPE_MEDIUM_BLOB:
                case MYSQL_TYPE_LONG_BLOB:
                case MYSQL_TYPE_BLOB:
                case MYSQL_TYPE_STRING:
                case MYSQL_TYPE_VAR_STRING:
                    // warning - the string will not be null-terminated if there is no space for it in the buffer
                    // when mysql_stmt_fetch returned MYSQL_DATA_TRUNCATED
                    // we cannot blindly null-terminate the data either as it may be retrieved as binary blob and not specifically a string
                    // in this case using Field::GetCString will result in garbage
                    if (fetched_length < buffer_length)
                        *((char*)buffer + fetched_length) = '\0';
                    break;
                default:
                    break;
                }
 
                m_rows[uint32(m_rowPosition) * m_fieldCount + fIndex].SetByteValue((char const*)buffer, fetched_length);
 
                // move buffer pointer to next part
                m_stmt->bind[fIndex].buffer = (char*)buffer + rowSize;
            }
            else
            {
                m_rows[uint32(m_rowPosition) * m_fieldCount + fIndex].SetByteValue(nullptr, *m_rBind[fIndex].length);
            }
        }
 
        m_rowPosition++;
    }
 
    m_rowPosition = 0;
 
    mysql_stmt_free_result(m_stmt);
}

References _NextRow(), CleanUp(), LOG_WARN, m_fieldCount, m_fieldMetadata, m_metadataResult, m_rBind, m_rowCount, m_rowPosition, m_rows, and m_stmt.

~PreparedResultSet()

PreparedResultSet::~PreparedResultSet

(

)

{
    CleanUp();
}

References CleanUp().

PreparedResultSet() [2/2]

PreparedResultSet::PreparedResultSet ( PreparedResultSet const &  right )

privatedelete

Member Function Documentation

_NextRow()

bool PreparedResultSet::_NextRow ( )

private

Only called in low-level code, namely the constructor Will iterate over every row of data and buffer it

{
    if (m_rowPosition >= m_rowCount)
        return false;
 
    int retval = mysql_stmt_fetch(m_stmt);
    return retval == 0 || retval == MYSQL_DATA_TRUNCATED;
}

References m_rowCount, m_rowPosition, and m_stmt.

Referenced by PreparedResultSet().

AssertRows()

void PreparedResultSet::AssertRows ( std::size_t  sizeRows )

private

{
    ASSERT(m_rowPosition < m_rowCount);
    ASSERT(sizeRows == m_fieldCount, "> Tuple size != count fields");
}

References ASSERT, m_fieldCount, m_rowCount, and m_rowPosition.

begin()

auto PreparedResultSet::begin ( )

inline

{ return ResultIterator<PreparedResultSet>(this); }

CleanUp()

void PreparedResultSet::CleanUp ( )

private

{
    if (m_metadataResult)
        mysql_free_result(m_metadataResult);
 
    if (m_rBind)
    {
        delete[](char*)m_rBind->buffer;
        delete[] m_rBind;
        m_rBind = nullptr;
    }
}

References m_metadataResult, and m_rBind.

Referenced by PreparedResultSet(), and ~PreparedResultSet().

end()

static auto PreparedResultSet::end ( )

inlinestatic

{ return ResultIterator<PreparedResultSet>(nullptr); }

Fetch()

Field * PreparedResultSet::Fetch

(

)

const

{
    ASSERT(m_rowPosition < m_rowCount);
    return const_cast<Field*>(&m_rows[uint32(m_rowPosition) * m_fieldCount]);
}

References ASSERT, m_fieldCount, m_rowCount, m_rowPosition, and m_rows.

FetchTuple()

template<typename... Ts>

std::tuple< Ts... > PreparedResultSet::FetchTuple ( )

inline

    {
        AssertRows(sizeof...(Ts));
 
        std::tuple<Ts...> theTuple = {};
 
        std::apply([this](Ts&... args)
        {
            uint8 index{ 0 };
            ((args = m_rows[uint32(m_rowPosition) * m_fieldCount + index].Get<Ts>(), index++), ...);
        }, theTuple);
 
        return theTuple;
    }

GetFieldCount()

uint32 PreparedResultSet::GetFieldCount ( ) const

inline

{ return m_fieldCount; }

GetRowCount()

uint64 PreparedResultSet::GetRowCount ( ) const

inline

{ return m_rowCount; }

Referenced by PreparedStatementTask::Execute(), DatabaseWorkerPool< T >::Query(), and SQLQueryHolderBase::SetPreparedResult().

NextRow()

bool PreparedResultSet::NextRow

(

)

Only updates the m_rowPosition so upper level code knows in which element of the rows vector to look

{
    if (++m_rowPosition >= m_rowCount)
        return false;
 
    return true;
}

References m_rowCount, and m_rowPosition.

operator=()

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

privatedelete

operator[]()

Field const & PreparedResultSet::operator[]

(

std::size_t

index

)

const

{
    ASSERT(m_rowPosition < m_rowCount);
    ASSERT(index < m_fieldCount);
    return m_rows[uint32(m_rowPosition) * m_fieldCount + index];
}

References ASSERT, m_fieldCount, m_rowCount, m_rowPosition, and m_rows.

Member Data Documentation

m_fieldCount

uint32 PreparedResultSet::m_fieldCount

protected

Referenced by AssertRows(), Fetch(), operator[](), and PreparedResultSet().

m_fieldMetadata

std::vector<QueryResultFieldMetadata> PreparedResultSet::m_fieldMetadata

protected

Referenced by PreparedResultSet().

m_metadataResult

MySQLResult* PreparedResultSet::m_metadataResult

private

Field metadata, returned by mysql_stmt_result_metadata.

Referenced by CleanUp(), and PreparedResultSet().

m_rBind

MySQLBind* PreparedResultSet::m_rBind

private

Referenced by CleanUp(), and PreparedResultSet().

m_rowCount

uint64 PreparedResultSet::m_rowCount

protected

Referenced by _NextRow(), AssertRows(), Fetch(), NextRow(), operator[](), and PreparedResultSet().

m_rowPosition

uint64 PreparedResultSet::m_rowPosition

protected

Referenced by _NextRow(), AssertRows(), Fetch(), NextRow(), operator[](), and PreparedResultSet().

m_rows

std::vector<Field> PreparedResultSet::m_rows

protected

Referenced by Fetch(), operator[](), and PreparedResultSet().

m_stmt

MySQLStmt* PreparedResultSet::m_stmt

private

Referenced by _NextRow(), and PreparedResultSet().