ResultSet Class Reference

#include "QueryResult.h"

Public Member Functions
	ResultSet (MySQLResult *result, MySQLField *fields, uint64 rowCount, uint32 fieldCount)
	~ResultSet ()
bool	NextRow ()
uint64	GetRowCount () const
uint32	GetFieldCount () const
std::string	GetFieldName (uint32 index) 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 >	_fieldMetadata
uint64	_rowCount
Field *	_currentRow
uint32	_fieldCount

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

Private Attributes
MySQLResult *	_result
MySQLField *	_fields

Detailed Description

Constructor & Destructor Documentation

ResultSet() [1/2]

ResultSet::ResultSet	(	MySQLResult *	result,
		MySQLField *	fields,
		uint64	rowCount,
		uint32	fieldCount
	)

                                                                                                :
    _rowCount(rowCount),
    _fieldCount(fieldCount),
    _result(result),
    _fields(fields)
{
    _fieldMetadata.resize(_fieldCount);
    _currentRow = new Field[_fieldCount];
 
    for (uint32 i = 0; i < _fieldCount; i++)
    {
        InitializeDatabaseFieldMetadata(&_fieldMetadata[i], &_fields[i], i);
        _currentRow[i].SetMetadata(&_fieldMetadata[i]);
    }
}

References _currentRow, _fieldCount, _fieldMetadata, _fields, and Field::SetMetadata().

~ResultSet()

ResultSet::~ResultSet

(

)

{
    CleanUp();
}

References CleanUp().

ResultSet() [2/2]

ResultSet::ResultSet ( ResultSet const &  right )

privatedelete

Member Function Documentation

AssertRows()

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

private

{
    ASSERT(sizeRows == _fieldCount);
}

References _fieldCount, and ASSERT.

begin()

auto ResultSet::begin ( )

inline

{ return ResultIterator<ResultSet>(this); }

CleanUp()

void ResultSet::CleanUp ( )

private

{
    if (_currentRow)
    {
        delete[] _currentRow;
        _currentRow = nullptr;
    }
 
    if (_result)
    {
        mysql_free_result(_result);
        _result = nullptr;
    }
}

References _currentRow, and _result.

Referenced by NextRow(), and ~ResultSet().

end()

static auto ResultSet::end ( )

inlinestatic

{ return ResultIterator<ResultSet>(nullptr); }

Fetch()

Field * ResultSet::Fetch ( ) const

inline

{ return _currentRow; }

FetchTuple()

template<typename... Ts>

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

inline

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

GetFieldCount()

uint32 ResultSet::GetFieldCount ( ) const

inline

{ return _fieldCount; }

GetFieldName()

std::string ResultSet::GetFieldName

(

uint32

index

)

const

{
    ASSERT(index < _fieldCount);
    return _fields[index].name;
}

References _fieldCount, _fields, and ASSERT.

GetRowCount()

uint64 ResultSet::GetRowCount ( ) const

inline

{ return _rowCount; }

Referenced by BasicStatementTask::Execute(), and DatabaseWorkerPool< T >::Query().

NextRow()

bool ResultSet::NextRow

(

)

{
    MYSQL_ROW row;
 
    if (!_result)
        return false;
 
    row = mysql_fetch_row(_result);
    if (!row)
    {
        CleanUp();
        return false;
    }
 
    unsigned long* lengths = mysql_fetch_lengths(_result);
    if (!lengths)
    {
        LOG_WARN("sql.sql", "{}:mysql_fetch_lengths, cannot retrieve value lengths. Error {}.", __FUNCTION__, mysql_error(_result->handle));
        CleanUp();
        return false;
    }
 
    for (uint32 i = 0; i < _fieldCount; i++)
        _currentRow[i].SetStructuredValue(row[i], lengths[i]);
 
    return true;
}

References _currentRow, _fieldCount, _result, CleanUp(), and LOG_WARN.

Referenced by BasicStatementTask::Execute(), and DatabaseWorkerPool< T >::Query().

operator=()

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

privatedelete

operator[]()

Field const & ResultSet::operator[]

(

std::size_t

index

)

const

{
    ASSERT(index < _fieldCount);
    return _currentRow[index];
}

References _currentRow, _fieldCount, and ASSERT.

Member Data Documentation

_currentRow

Field* ResultSet::_currentRow

protected

Referenced by CleanUp(), NextRow(), operator[](), and ResultSet().

_fieldCount

uint32 ResultSet::_fieldCount

protected

Referenced by AssertRows(), GetFieldName(), NextRow(), operator[](), and ResultSet().

_fieldMetadata

std::vector<QueryResultFieldMetadata> ResultSet::_fieldMetadata

protected

Referenced by ResultSet().

_fields

MySQLField* ResultSet::_fields

private

Referenced by GetFieldName(), and ResultSet().

_result

MySQLResult* ResultSet::_result

private

Referenced by CleanUp(), and NextRow().

_rowCount

uint64 ResultSet::_rowCount

protected