PlayerDump.cpp File Reference

#include "PlayerDump.h"
#include "AccountMgr.h"
#include "CharacterCache.h"
#include "Common.h"
#include "DatabaseEnv.h"
#include "Log.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "StringConvert.h"
#include "World.h"
#include <fstream>
#include <sstream>

Go to the source code of this file.

Classes
struct	FileCloser
struct	BaseTable
struct	DumpTable
class	StringTransaction
struct	TableField
struct	TableStruct

Typedefs
typedef std::unique_ptr< FILE, FileCloser >	FileHandle

Enumerations
enum	GuidType : uint8 {   GUID_TYPE_ACCOUNT ,   GUID_TYPE_CHAR ,   GUID_TYPE_PET ,   GUID_TYPE_MAIL ,   GUID_TYPE_ITEM ,   GUID_TYPE_EQUIPMENT_SET ,   GUID_TYPE_NULL }

Functions
FileHandle	GetFileHandle (char const *path, char const *mode)
bool	StringsEqualCaseInsensitive (std::string const &left, std::string const &right)
auto	FindColumnByName (TableStruct &tableStruct, std::string const &columnName) -> decltype(tableStruct.TableFields.begin())
int32	GetColumnIndexByName (TableStruct const &tableStruct, std::string const &columnName)
void	MarkDependentColumn (TableStruct &tableStruct, std::string const &columnName, GuidType dependentType)
void	MarkWhereField (TableStruct &tableStruct, std::string const &whereField)
void	AssertBaseTable (BaseTable const &baseTable)
bool	FindColumn (TableStruct const &ts, std::string const &str, std::string const &column, std::string::size_type &s, std::string::size_type &e)
std::string	GetTableName (std::string const &str)
bool	ValidateFields (TableStruct const &ts, std::string const &str, std::size_t lineNumber)
bool	ChangeColumn (TableStruct const &ts, std::string &str, std::string const &column, std::string const &with, bool allowZero=false)
std::string	GetColumn (TableStruct const &ts, std::string &str, std::string const &column)
template<typename T , template< class, class, class... > class MapType, class... Rest>
T	RegisterNewGuid (T oldGuid, MapType< T, T, Rest... > &guidMap, T guidOffset)
template<typename T , template< class, class, class... > class MapType, class... Rest>
bool	ChangeGuid (TableStruct const &ts, std::string &str, std::string const &column, MapType< T, T, Rest... > &guidMap, T guidOffset, bool allowZero=false)
void	AppendTableDump (StringTransaction &trans, TableStruct const &tableStruct, QueryResult result)
std::string	GenerateWhereStr (std::string const &field, ObjectGuid::LowType guid)
template<typename T , template< class, class... > class SetType, class... Rest>
std::string	GenerateWhereStr (std::string const &field, SetType< T, Rest... > const &guidSet)
void	FixNULLfields (std::string &line)

Variables
BaseTable const	BaseTables []
DumpTable const	DumpTables []
uint32 const	DUMP_TABLE_COUNT = std::extent<decltype(DumpTables)>::value
std::vector< TableStruct >	CharacterTables

Typedef Documentation

FileHandle

typedef std::unique_ptr<FILE, FileCloser> FileHandle

Enumeration Type Documentation

GuidType

enum GuidType : uint8

Enumerator
GUID_TYPE_ACCOUNT
GUID_TYPE_CHAR
GUID_TYPE_PET
GUID_TYPE_MAIL
GUID_TYPE_ITEM
GUID_TYPE_EQUIPMENT_SET
GUID_TYPE_NULL

{
    // 32 bit long guids
    GUID_TYPE_ACCOUNT,
    GUID_TYPE_CHAR,
    GUID_TYPE_PET,
    GUID_TYPE_MAIL,
    GUID_TYPE_ITEM,
 
    // 64 bit long guids
    GUID_TYPE_EQUIPMENT_SET,
 
    // special types
    GUID_TYPE_NULL // set to null
};

Function Documentation

AppendTableDump()

void AppendTableDump ( StringTransaction &  trans, TableStruct const &  tableStruct, QueryResult  result  )

inline

{
    if (!result)
        return;
 
    do
    {
        std::ostringstream ss;
        ss << "INSERT INTO `" << tableStruct.TableName << "` (";
        for (auto itr = tableStruct.TableFields.begin(); itr != tableStruct.TableFields.end();)
        {
            ss << '`' << itr->FieldName << '`';
            ++itr;
 
            if (itr != tableStruct.TableFields.end())
                ss << ", ";
        }
        ss << ") VALUES (";
 
        uint32 const fieldSize = uint32(tableStruct.TableFields.size());
        Field* fields = result->Fetch();
 
        for (uint32 i = 0; i < fieldSize;)
        {
            std::string cString = fields[i].Get<std::string>();
            ++i;
 
            // null pointer -> we have null
            if (cString.empty())
                ss << "'NULL'";
            else
            {
                std::string s(cString);
                CharacterDatabase.EscapeString(s);
                ss << '\'' << s << '\'';
            }
 
            if (i != fieldSize)
                ss << ", ";
        }
        ss << ");";
 
        trans.Append(ss.str().c_str());
    } while (result->NextRow());
}

References StringTransaction::Append(), CharacterDatabase, Field::Get(), TableStruct::TableFields, and TableStruct::TableName.

Referenced by PlayerDumpWriter::AppendTable().

AssertBaseTable()

void AssertBaseTable ( BaseTable const &  baseTable )

inline

{
    auto itr = std::find_if(CharacterTables.begin(), CharacterTables.end(), [baseTable](TableStruct const& tableStruct) -> bool
    {
        return StringsEqualCaseInsensitive(tableStruct.TableName, baseTable.TableName);
    });
 
    ASSERT(itr != CharacterTables.end());
 
    auto columnItr = FindColumnByName(*itr, baseTable.PrimaryKey);
    ASSERT(columnItr != itr->TableFields.end());
 
    columnItr = FindColumnByName(*itr, baseTable.PlayerGuid);
    ASSERT(columnItr != itr->TableFields.end());
}

References ASSERT, CharacterTables, FindColumnByName(), BaseTable::PlayerGuid, and BaseTable::PrimaryKey.

Referenced by PlayerDump::InitializeTables().

ChangeColumn()

bool ChangeColumn ( TableStruct const &  ts, std::string &  str, std::string const &  column, std::string const &  with, bool  allowZero = false  )

inline

{
    std::string::size_type s, e;
    if (!FindColumn(ts, str, column, s, e))
        return false;
 
    if (allowZero && str.substr(s, e - s) == "0")
        return true;                                        // not an error
 
    str.replace(s, e - s, with);
    return true;
}

References FindColumn().

Referenced by ChangeGuid(), and PlayerDumpReader::LoadDump().

ChangeGuid()

template<typename T , template< class, class, class... > class MapType, class... Rest>

bool ChangeGuid ( TableStruct const &  ts, std::string &  str, std::string const &  column, MapType< T, T, Rest... > &  guidMap, T  guidOffset, bool  allowZero = false  )

inline

{
    T oldGuid(*Acore::StringTo<uint64>(GetColumn(ts, str, column)));
    if (allowZero && !oldGuid)
        return true;                                        // not an error
 
    std::string chritem;
    T newGuid = RegisterNewGuid(oldGuid, guidMap, guidOffset);
    chritem = std::to_string(newGuid);
 
    return ChangeColumn(ts, str, column, chritem, allowZero);
}

References ChangeColumn(), GetColumn(), and RegisterNewGuid().

Referenced by PlayerDumpReader::LoadDump().

FindColumn()

bool FindColumn ( TableStruct const &  ts, std::string const &  str, std::string const &  column, std::string::size_type &  s, std::string::size_type &  e  )

inline

{
    int32 columnIndex = GetColumnIndexByName(ts, column);
    if (columnIndex == -1)
        return false;
 
    // array indices start at 0, compensate
    ++columnIndex;
 
    s = str.find("VALUES ('");
    if (s == std::string::npos)
        return false;
    s += 9;
 
    do
    {
        e = str.find('\'', s);
        if (e == std::string::npos)
            return false;
    } while (str[e - 1] == '\\');
 
    for (int32 i = 1; i < columnIndex; ++i)
    {
        do
        {
            // length of "', '"
            s = e + 4;
            e = str.find('\'', s);
            if (e == std::string::npos)
                return false;
        } while (str[e - 1] == '\\');
    }
    return true;
}

References GetColumnIndexByName().

Referenced by ChangeColumn(), and GetColumn().

FindColumnByName()

auto FindColumnByName ( TableStruct &  tableStruct, std::string const &  columnName  ) -> decltype(tableStruct.TableFields.begin())

inline

{
    return std::find_if(tableStruct.TableFields.begin(), tableStruct.TableFields.end(), [columnName](TableField const& tableField) -> bool
    {
        return StringsEqualCaseInsensitive(tableField.FieldName, columnName);
    });
}

Referenced by AssertBaseTable(), MarkDependentColumn(), and MarkWhereField().

FixNULLfields()

void FixNULLfields ( std::string &  line )

inline

{
    static std::string const NullString("'NULL'");
    std::size_t pos = line.find(NullString);
    while (pos != std::string::npos)
    {
        line.replace(pos, NullString.length(), "NULL");
        pos = line.find(NullString);
    }
}

Referenced by PlayerDumpReader::LoadDump().

GenerateWhereStr() [1/2]

std::string GenerateWhereStr ( std::string const &  field, ObjectGuid::LowType  guid  )

inline

{
    std::ostringstream whereStr;
    whereStr << field << " = '" << guid << '\'';
    return whereStr.str();
}

Referenced by PlayerDumpWriter::AppendTable(), and PlayerDumpWriter::PopulateGuids().

GenerateWhereStr() [2/2]

template<typename T , template< class, class... > class SetType, class... Rest>

std::string GenerateWhereStr ( std::string const &  field, SetType< T, Rest... > const &  guidSet  )

inline

{
    std::ostringstream whereStr;
    whereStr << field << " IN ('";
    for (auto itr = guidSet.begin(); itr != guidSet.end();)
    {
        whereStr << *itr;
        ++itr;
 
        if (whereStr.str().size() > MAX_QUERY_LEN - 50)      // near to max query
            break;
 
        if (itr != guidSet.end())
            whereStr << "','";
    }
    whereStr << "')";
    return whereStr.str();
}

References MAX_QUERY_LEN.

GetColumn()

std::string GetColumn ( TableStruct const &  ts, std::string &  str, std::string const &  column  )

inline

{
    std::string::size_type s, e;
    if (!FindColumn(ts, str, column, s, e))
        return "";
 
    return str.substr(s, e - s);
}

References FindColumn().

Referenced by ChangeGuid(), and PlayerDumpReader::LoadDump().

GetColumnIndexByName()

int32 GetColumnIndexByName ( TableStruct const &  tableStruct, std::string const &  columnName  )

inline

{
    auto itr = tableStruct.FieldIndices.find(columnName);
    if (itr == tableStruct.FieldIndices.end())
        return -1;
 
    return itr->second;
}

References TableStruct::FieldIndices.

Referenced by PlayerDumpWriter::AppendTable(), FindColumn(), and ValidateFields().

GetFileHandle()

FileHandle GetFileHandle ( char const *  path, char const *  mode  )

inline

{
    return FileHandle(fopen(path, mode), FileCloser());
}

Referenced by PlayerDumpWriter::WriteDumpToFile().

GetTableName()

std::string GetTableName ( std::string const &  str )

inline

{
    // length of "INSERT INTO `"
    static std::string::size_type const s = 13;
    std::string::size_type e = str.find('`', s);
    if (e == std::string::npos)
        return "";
 
    return str.substr(s, e - s);
}

Referenced by PlayerDumpReader::LoadDump().

MarkDependentColumn()

void MarkDependentColumn ( TableStruct &  tableStruct, std::string const &  columnName, GuidType  dependentType  )

inline

{
    auto itr = FindColumnByName(tableStruct, columnName);
    if (itr == tableStruct.TableFields.end())
    {
        LOG_FATAL("server.loading", "Column `{}` declared in table `{}` marked as dependent but doesn't exist, PlayerDump will not work properly, please update table definitions",
            columnName, tableStruct.TableName);
        ABORT();
        return;
    }
 
    if (itr->IsDependentField)
    {
        LOG_FATAL("server.loading", "Attempt to mark column `{}` in table `{}` as dependent column but already marked! please check your code.",
            columnName, tableStruct.TableName);
        ABORT();
        return;
    }
 
    itr->IsDependentField = true;
    itr->FieldGuidType = dependentType;
}

References ABORT, FindColumnByName(), LOG_FATAL, TableStruct::TableFields, and TableStruct::TableName.

Referenced by PlayerDump::InitializeTables().

MarkWhereField()

void MarkWhereField ( TableStruct &  tableStruct, std::string const &  whereField  )

inline

{
    ASSERT(tableStruct.WhereFieldName.empty());
 
    auto whereFieldItr = FindColumnByName(tableStruct, whereField);
    if (whereFieldItr == tableStruct.TableFields.end())
    {
        LOG_FATAL("server.loading", "Column name `{}` set as 'WHERE' column for table `{}` doesn't exist. PlayerDump won't work properly",
            whereField, tableStruct.TableName);
        ABORT();
        return;
    }
 
    tableStruct.WhereFieldName = whereField;
}

References ABORT, ASSERT, FindColumnByName(), LOG_FATAL, TableStruct::TableFields, TableStruct::TableName, and TableStruct::WhereFieldName.

Referenced by PlayerDump::InitializeTables().

RegisterNewGuid()

template<typename T , template< class, class, class... > class MapType, class... Rest>

T RegisterNewGuid ( T  oldGuid, MapType< T, T, Rest... > &  guidMap, T  guidOffset  )

inline

{
    auto itr = guidMap.find(oldGuid);
    if (itr != guidMap.end())
        return itr->second;
 
    T newguid = guidOffset + T(guidMap.size());
    guidMap.emplace(oldGuid, newguid);
    return newguid;
}

Referenced by ChangeGuid().

StringsEqualCaseInsensitive()

bool StringsEqualCaseInsensitive ( std::string const &  left, std::string const &  right  )

inline

{
    std::string upperLeftString = left;
    bool leftResult = Utf8ToUpperOnlyLatin(upperLeftString);
    ASSERT(leftResult);
 
    std::string upperRightString = right;
    bool rightResult = Utf8ToUpperOnlyLatin(upperRightString);
    ASSERT(rightResult);
 
    return upperLeftString == upperRightString;
}

References ASSERT, and Utf8ToUpperOnlyLatin().

ValidateFields()

bool ValidateFields ( TableStruct const &  ts, std::string const &  str, std::size_t  lineNumber  )

inline

{
    std::string::size_type s = str.find("` VALUES (");
    if (s != std::string::npos) // old dump format (no column names)
        return true;
 
    // new format has insert with columns, need validation else we risk executing an invalid query
    s = str.find("` (`");
    if (s == std::string::npos)
    {
        LOG_ERROR("misc", "LoadPlayerDump: (line {}) dump format not recognized.", lineNumber);
        return false;
    }
    s += 4;
 
    std::string::size_type valPos = str.find("VALUES ('");
    std::string::size_type e = str.find('`', s);
    if (e == std::string::npos || valPos == std::string::npos)
    {
        LOG_ERROR("misc", "LoadPlayerDump: (line {}) unexpected end of line", lineNumber);
        return false;
    }
 
    do
    {
        std::string column = str.substr(s, e - s);
        int32 columnIndex = GetColumnIndexByName(ts, column);
        if (columnIndex == -1)
        {
            LOG_ERROR("misc", "LoadPlayerDump: (line {}) unknown column name `{}` for table `{}`, aborting due to incompatible DB structure.", lineNumber, column, ts.TableName);
            return false;
        }
 
        // length of "`, `"
        s = e + 4;
        e = str.find('`', s);
    } while (e < valPos);
 
    return true;
}

References GetColumnIndexByName(), LOG_ERROR, and TableStruct::TableName.

Referenced by PlayerDumpReader::LoadDump().

Variable Documentation

BaseTables

BaseTable const BaseTables[]

Initial value:

=
{
    { "character_pet",           "id",      "owner",      GUID_TYPE_PET           },
    { "mail",                    "id",      "receiver",   GUID_TYPE_MAIL          },
    { "item_instance",           "guid",    "owner_guid", GUID_TYPE_ITEM          },
 
    { "character_equipmentsets", "setguid", "guid",       GUID_TYPE_EQUIPMENT_SET }
}

Referenced by PlayerDump::InitializeTables(), and PlayerDumpWriter::PopulateGuids().

CharacterTables

std::vector<TableStruct> CharacterTables

Referenced by AssertBaseTable(), PlayerDumpWriter::GetDump(), PlayerDump::InitializeTables(), and PlayerDumpReader::LoadDump().

DUMP_TABLE_COUNT

uint32 const DUMP_TABLE_COUNT = std::extent<decltype(DumpTables)>::value

Referenced by PlayerDumpWriter::GetDump(), PlayerDump::InitializeTables(), and PlayerDumpReader::LoadDump().

DumpTables

DumpTable const DumpTables[]

Referenced by PlayerDumpWriter::GetDump(), PlayerDump::InitializeTables(), and PlayerDumpReader::LoadDump().