PreparedResultSet Class Reference

#include <QueryResult.h>

Public Member Functions
	PreparedResultSet (MYSQL_STMT *stmt, MYSQL_RES *result, uint64 rowCount, uint32 fieldCount)
	~PreparedResultSet ()
bool	NextRow ()
uint64	GetRowCount () const
uint32	GetFieldCount () const
Field *	Fetch () const
Field const &	operator[] (uint32 index) const

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

Private Member Functions
void	CleanUp ()
bool	_NextRow ()
	PreparedResultSet (PreparedResultSet const &right)=delete
PreparedResultSet &	operator= (PreparedResultSet const &right)=delete

Private Attributes
MYSQL_BIND *	m_rBind
MYSQL_STMT *	m_stmt
MYSQL_RES *	m_metadataResult
	Field metadata, returned by mysql_stmt_result_metadata. More...
my_bool *	m_isNull
unsigned long *	m_length

Constructor & Destructor Documentation

PreparedResultSet::PreparedResultSet	(	MYSQL_STMT *	stmt,
		MYSQL_RES *	result,
		uint64	rowCount,
		uint32	fieldCount
	)

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

 :
m_rowCount(rowCount),
m_rowPosition(0),
m_fieldCount(fieldCount),
m_rBind(NULL),
m_stmt(stmt),
m_metadataResult(result),
m_isNull(NULL),
m_length(NULL)
{
 if (!m_metadataResult)
 return;

 if (m_stmt->bind_result_done)
 {
 delete[] m_stmt->bind->length;
 delete[] m_stmt->bind->is_null;
 }

 m_rBind = new MYSQL_BIND[m_fieldCount];
 m_isNull = new my_bool[m_fieldCount];
 m_length = new unsigned long[m_fieldCount];

 memset(m_isNull, 0, sizeof(my_bool) * m_fieldCount);
 memset(m_rBind, 0, sizeof(MYSQL_BIND) * 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))
 {
 TC_LOG_WARN("sql.sql", "%s:mysql_stmt_store_result, cannot bind result from MySQL server. Error: %s", __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
 MYSQL_FIELD* field = mysql_fetch_fields(m_metadataResult);
 std::size_t rowSize = 0;
 for (uint32 i = 0; i < m_fieldCount; ++i)
 {
 uint32 size = Field::SizeForType(&field[i]);
 rowSize += size;

 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 = NULL;
 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))
 {
 TC_LOG_WARN("sql.sql", "%s:mysql_stmt_bind_result, cannot bind result from MySQL server. Error: %s", __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)
 {
 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
 // TODO: remove Field::GetCString and use boost::string_ref (currently proposed for TS as string_view, maybe in C++17)
 if (fetched_length < buffer_length)
 *((char*)buffer + fetched_length) = '\0';
 break;
 default:
 break;
 }

 m_rows[uint32(m_rowPosition) * m_fieldCount + fIndex].SetByteValue(
 buffer,
 m_rBind[fIndex].buffer_type,
 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].buffer_type,
 *m_rBind[fIndex].length);
 }

#ifdef TRINITY_DEBUG
 m_rows[uint32(m_rowPosition) * m_fieldCount + fIndex].SetMetadata(&field[fIndex], fIndex);
#endif
 }
 m_rowPosition++;
 }
 m_rowPosition = 0;

 mysql_stmt_free_result(m_stmt);
}

Here is the call graph for this function:

PreparedResultSet::~PreparedResultSet

(

)

{
 CleanUp();
}

Here is the call graph for this function:

PreparedResultSet::PreparedResultSet ( PreparedResultSet const &  right )

privatedelete

Member Function Documentation

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;
}

Here is the caller graph for this function:

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;
 }
}

Here is the caller graph for this function:

Field* PreparedResultSet::Fetch ( ) const

inline

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

uint32 PreparedResultSet::GetFieldCount ( ) const

inline

{ return m_fieldCount; }

uint64 PreparedResultSet::GetRowCount ( ) const

inline

{ return m_rowCount; }

Here is the caller graph for this function:

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;
}

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

privatedelete

Field const& PreparedResultSet::operator[] ( uint32  index ) const

inline

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

Member Data Documentation

uint32 PreparedResultSet::m_fieldCount

protected

my_bool* PreparedResultSet::m_isNull

private

unsigned long* PreparedResultSet::m_length

private

MYSQL_RES* PreparedResultSet::m_metadataResult

private

Field metadata, returned by mysql_stmt_result_metadata.

MYSQL_BIND* PreparedResultSet::m_rBind

private

uint64 PreparedResultSet::m_rowCount

protected

uint64 PreparedResultSet::m_rowPosition

protected

std::vector<Field> PreparedResultSet::m_rows

protected

MYSQL_STMT* PreparedResultSet::m_stmt

private

---

The documentation for this class was generated from the following files:

• src/server/database/Database/QueryResult.h
• src/server/database/Database/QueryResult.cpp