DBCDatabaseLoader Struct Reference

#include "DBCDatabaseLoader.h"

Public Member Functions
	DBCDatabaseLoader (char const *dbTable, char const *dbcFormatString, std::vector< char * > &stringPool)
char *	Load (uint32 &records, char **&indexTable)

Private Member Functions
char *	CloneStringToPool (std::string const &str)
	DBCDatabaseLoader (DBCDatabaseLoader const &right)=delete
DBCDatabaseLoader &	operator= (DBCDatabaseLoader const &right)=delete

Private Attributes
char const *	_sqlTableName
char const *	_dbcFormat
int32	_sqlIndexPos
uint32	_recordSize
std::vector< char * > &	_stringPool

Detailed Description

Constructor & Destructor Documentation

DBCDatabaseLoader() [1/2]

DBCDatabaseLoader::DBCDatabaseLoader	(	char const *	dbTable,
		char const *	dbcFormatString,
		std::vector< char * > &	stringPool
	)

    : _sqlTableName(tableName),
      _dbcFormat(dbcFormatString),
      _sqlIndexPos(0),
      _recordSize(0),
      _stringPool(stringPool)
{
    // Get sql index position
    int32 indexPos = -1;
    _recordSize = DBCFileLoader::GetFormatRecordSize(_dbcFormat, &indexPos);
 
    ASSERT(_recordSize);
}

References _dbcFormat, _recordSize, ASSERT, and DBCFileLoader::GetFormatRecordSize().

DBCDatabaseLoader() [2/2]

DBCDatabaseLoader::DBCDatabaseLoader ( DBCDatabaseLoader const &  right )

privatedelete

Member Function Documentation

CloneStringToPool()

char * DBCDatabaseLoader::CloneStringToPool ( std::string const &  str )

private

{
    char* buf = new char[str.size() + 1];
    memcpy(buf, str.c_str(), str.size() + 1);
    _stringPool.push_back(buf);
    return buf;
}

References _stringPool.

Referenced by Load().

Load()

char * DBCDatabaseLoader::Load	(	uint32 &	records,
		char **&	indexTable
	)

{
    std::string query = Acore::StringFormat("SELECT * FROM `{}` ORDER BY `ID` DESC", _sqlTableName);
 
    // no error if empty set
    QueryResult result = WorldDatabase.Query(query);
    if (!result)
        return nullptr;
 
    // Check if sql index pos is valid
    if (int32(result->GetFieldCount() - 1) < _sqlIndexPos)
    {
        ASSERT(false, "Invalid index pos for dbc: '{}'", _sqlTableName);
        return nullptr;
    }
 
    // Resize index table
    // database query *MUST* contain ORDER BY `index_field` DESC clause
    uint32 indexTableSize = std::max(records, (*result)[_sqlIndexPos].Get<uint32>() + 1);
    if (indexTableSize > records)
    {
        char** tmpIdxTable = new char* [indexTableSize];
        memset(tmpIdxTable, 0, indexTableSize * sizeof(char*));
        memcpy(tmpIdxTable, indexTable, records * sizeof(char*));
        delete[] indexTable;
        indexTable = tmpIdxTable;
    }
 
    std::unique_ptr<char[]> dataTable = std::make_unique<char[]>(result->GetRowCount() * _recordSize);
    std::unique_ptr<uint32[]> newIndexes = std::make_unique<uint32[]>(result->GetRowCount());
    uint32 newRecords = 0;
 
    // Insert sql data into the data array
    do
    {
        Field* fields = result->Fetch();
        uint32 indexValue = fields[_sqlIndexPos].Get<uint32>();
        char* dataValue = indexTable[indexValue];
 
        // If exist in DBC file override from DB
        newIndexes[newRecords] = indexValue;
        dataValue = &dataTable[newRecords++ * _recordSize];
 
        uint32 dataOffset = 0;
        uint32 sqlColumnNumber = 0;
        char const* dbcFormat = _dbcFormat;
 
        for (; (*dbcFormat); ++dbcFormat)
        {
            switch (*dbcFormat)
            {
                case FT_FLOAT:
                    *reinterpret_cast<float*>(&dataValue[dataOffset]) = fields[sqlColumnNumber].Get<float>();
                    dataOffset += sizeof(float);
                    break;
                case FT_IND:
                case FT_INT:
                    *reinterpret_cast<uint32*>(&dataValue[dataOffset]) = fields[sqlColumnNumber].Get<uint32>();
                    dataOffset += sizeof(uint32);
                    break;
                case FT_BYTE:
                    *reinterpret_cast<uint8*>(&dataValue[dataOffset]) = fields[sqlColumnNumber].Get<uint8>();
                    dataOffset += sizeof(uint8);
                    break;
                case FT_STRING:
                    *reinterpret_cast<char**>(&dataValue[dataOffset]) = CloneStringToPool(fields[sqlColumnNumber].Get<std::string>());
                    dataOffset += sizeof(char*);
                    break;
                case FT_SORT:
                case FT_NA:
                case FT_NA_BYTE:
                    break;
                default:
                    ASSERT(false, "Unsupported data type '{}' in table '{}'", *dbcFormat, _sqlTableName);
                    return nullptr;
            }
 
            ++sqlColumnNumber;
        }
 
        ASSERT(sqlColumnNumber == result->GetFieldCount(), "SQL format string does not match database for table: '{}'", _sqlTableName);
        ASSERT(dataOffset == _recordSize);
    } while (result->NextRow());
 
    ASSERT(newRecords == result->GetRowCount());
 
    // insert new records to index table
    for (uint32 i = 0; i < newRecords; ++i)
    {
        // cppcheck-suppress autoVariables
        indexTable[newIndexes[i]] = &dataTable[i * _recordSize];
    }
 
    records = indexTableSize;
 
    return dataTable.release();
}

References _dbcFormat, _recordSize, _sqlIndexPos, _sqlTableName, ASSERT, CloneStringToPool(), FT_BYTE, FT_FLOAT, FT_IND, FT_INT, FT_NA, FT_NA_BYTE, FT_SORT, FT_STRING, Field::Get(), Acore::StringFormat(), and WorldDatabase.

operator=()

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

privatedelete

Member Data Documentation

_dbcFormat

char const* DBCDatabaseLoader::_dbcFormat

private

Referenced by DBCDatabaseLoader(), and Load().

_recordSize

uint32 DBCDatabaseLoader::_recordSize

private

Referenced by DBCDatabaseLoader(), and Load().

_sqlIndexPos

int32 DBCDatabaseLoader::_sqlIndexPos

private

Referenced by Load().

_sqlTableName

char const* DBCDatabaseLoader::_sqlTableName

private

Referenced by Load().

_stringPool

std::vector<char*>& DBCDatabaseLoader::_stringPool

private

Referenced by CloneStringToPool().