DB2DatabaseLoader Class Reference

#include <DB2StorageLoader.h>

Public Member Functions
	DB2DatabaseLoader (std::string const &storageName)
char *	Load (const char *format, HotfixDatabaseStatements preparedStatement, uint32 &records, char **&indexTable, char *&stringHolders, std::list< char * > &stringPool)
void	LoadStrings (const char *format, HotfixDatabaseStatements preparedStatement, uint32 locale, char **&indexTable, std::list< char * > &stringPool)

Static Public Member Functions
static char *	AddString (char const **holder, std::string const &value)

Private Attributes
std::string	_storageName

Constructor & Destructor Documentation

DB2DatabaseLoader::DB2DatabaseLoader ( std::string const &  storageName )

inlineexplicit

: _storageName(storageName) { }

Member Function Documentation

char * DB2DatabaseLoader::AddString ( char const **  holder, std::string const &  value  )

static

{
 if (!value.empty())
 {
 std::size_t existingLength = strlen(*holder);
 if (existingLength >= value.length())
 {
 // Reuse existing storage if there is enough space
 char* str = const_cast<char*>(*holder);
 memcpy(str, value.c_str(), value.length());
 str[value.length()] = '\0';
 return nullptr;
 }

 char* str = new char[value.length() + 1];
 memcpy(str, value.c_str(), value.length());
 str[value.length()] = '\0';
 *holder = str;
 return str;
 }

 return nullptr;
}

Here is the caller graph for this function:

char * DB2DatabaseLoader::Load	(	const char *	format,
		HotfixDatabaseStatements	preparedStatement,
		uint32 &	records,
		char **&	indexTable,
		char *&	stringHolders,
		std::list< char * > &	stringPool
	)

{
 // Even though this query is executed only once, prepared statement is used to send data from mysql server in binary format
 PreparedQueryResult result = HotfixDatabase.Query(HotfixDatabase.GetPreparedStatement(preparedStatement));
 if (!result)
 return nullptr;

 uint32 const fieldCount = strlen(format);
 if (fieldCount != result->GetFieldCount())
 return nullptr;

 // get struct size and index pos
 int32 indexField;
 uint32 recordSize = DB2FileLoader::GetFormatRecordSize(format, &indexField);

 // we store flat holders pool as single memory block
 size_t stringFields = DB2FileLoader::GetFormatStringFieldCount(format);

 // each string field at load have array of string for each locale
 size_t stringHolderSize = sizeof(char*) * TOTAL_LOCALES;
 size_t stringHoldersRecordPoolSize = stringFields * stringHolderSize;

 if (stringFields)
 {
 size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * result->GetRowCount();
 stringHolders = new char[stringHoldersPoolSize];

 // DB2 strings expected to have at least empty string
 for (size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i)
 ((char const**)stringHolders)[i] = nullStr;
 }
 else
 stringHolders = nullptr;

 // Resize index table
 // database query *MUST* contain ORDER BY `index_field` DESC clause
 uint32 indexTableSize;
 if (indexField >= 0)
 {
 indexTableSize = (*result)[indexField].GetUInt32() + 1;
 if (indexTableSize < records)
 indexTableSize = records;
 }
 else
 indexTableSize = records + result->GetRowCount();

 if (indexTableSize > records)
 {
 char** tmpIdxTable = new char*[indexTableSize];
 memset(tmpIdxTable, 0, indexTableSize * sizeof(char*));
 memcpy(tmpIdxTable, indexTable, records * sizeof(char*));
 delete[] indexTable;
 indexTable = tmpIdxTable;
 }

 char* tempDataTable = new char[result->GetRowCount() * recordSize];
 uint32* newIndexes = new uint32[result->GetRowCount()];
 uint32 rec = 0;
 uint32 newRecords = 0;

 do
 {
 Field* fields = result->Fetch();
 uint32 offset = 0;
 uint32 stringFieldNumInRecord = 0;

 uint32 indexValue;
 if (indexField >= 0)
 indexValue = fields[indexField].GetUInt32();
 else
 indexValue = records + rec;

 // Attempt to overwrite existing data
 char* dataValue = indexTable[indexValue];
 if (!dataValue)
 {
 newIndexes[newRecords] = indexValue;
 dataValue = &tempDataTable[newRecords++ * recordSize];
 }

 for (uint32 f = 0; f < fieldCount; f++)
 {
 switch (format[f])
 {
 case FT_FLOAT:
 *((float*)(&dataValue[offset])) = fields[f].GetFloat();
 offset += 4;
 break;
 case FT_IND:
 case FT_INT:
 *((int32*)(&dataValue[offset])) = fields[f].GetInt32();
 offset += 4;
 break;
 case FT_BYTE:
 *((int8*)(&dataValue[offset])) = fields[f].GetInt8();
 offset += 1;
 break;
 case FT_LONG:
 *((int64*)(&dataValue[offset])) = fields[f].GetInt64();
 offset += 8;
 break;
 case FT_STRING:
 {
 LocalizedString** slot = (LocalizedString**)(&dataValue[offset]);
 *slot = (LocalizedString*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringHolderSize * stringFieldNumInRecord]);
 ASSERT(*slot);

 // Value in database in main table field must be for enUS locale
 if (char* str = AddString(&(*slot)->Str[LOCALE_enUS], fields[f].GetString()))
 stringPool.push_back(str);

 ++stringFieldNumInRecord;
 offset += sizeof(char*);
 break;
 }
 case FT_STRING_NOT_LOCALIZED:
 {
 char const** slot = (char const**)(&dataValue[offset]);
 *slot = (char*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringHolderSize * stringFieldNumInRecord]);
 ASSERT(*slot);

 // Value in database in main table field must be for enUS locale
 if (char* str = AddString(slot, fields[f].GetString()))
 stringPool.push_back(str);

 ++stringFieldNumInRecord;
 offset += sizeof(char*);
 break;
 }
 }
 }

 ASSERT(offset == recordSize);
 ++rec;
 } while (result->NextRow());

 if (!newRecords)
 {
 delete[] tempDataTable;
 delete[] newIndexes;
 return nullptr;
 }

 // Compact new data table to only contain new records not previously loaded from file
 char* dataTable = new char[newRecords * recordSize];
 memcpy(dataTable, tempDataTable, newRecords * recordSize);

 // insert new records to index table
 for (uint32 i = 0; i < newRecords; ++i)
 indexTable[newIndexes[i]] = &dataTable[i * recordSize];

 delete[] tempDataTable;
 delete[] newIndexes;

 records = indexTableSize;

 return dataTable;
}

Here is the call graph for this function:

void DB2DatabaseLoader::LoadStrings	(	const char *	format,
		HotfixDatabaseStatements	preparedStatement,
		uint32	locale,
		char **&	indexTable,
		std::list< char * > &	stringPool
	)

{
 PreparedStatement* stmt = HotfixDatabase.GetPreparedStatement(preparedStatement);
 stmt->setString(0, localeNames[locale]);
 PreparedQueryResult result = HotfixDatabase.Query(stmt);
 if (!result)
 return;

 size_t stringFields = DB2FileLoader::GetFormatLocalizedStringFieldCount(format);
 if (result->GetFieldCount() != stringFields + 1 /*ID*/)
 return;

 uint32 const fieldCount = strlen(format);
 int32 indexField;
 uint32 recordSize = DB2FileLoader::GetFormatRecordSize(format, &indexField);
 ASSERT(indexField >= 0, "DB2Storage must be indexed to load localized strings");

 do
 {
 Field* fields = result->Fetch();
 uint32 offset = 0;
 uint32 stringFieldNumInRecord = 0;
 uint32 indexValue = fields[0].GetUInt32();

 // Attempt to overwrite existing data
 if (char* dataValue = indexTable[indexValue])
 {
 for (uint32 x = 0; x < fieldCount; x++)
 {
 switch (format[x])
 {
 case FT_FLOAT:
 case FT_IND:
 case FT_INT:
 offset += 4;
 break;
 case FT_BYTE:
 offset += 1;
 break;
 case FT_LONG:
 offset += 8;
 break;
 case FT_STRING:
 {
 // fill only not filled entries
 LocalizedString* db2str = *(LocalizedString**)(&dataValue[offset]);
 if (db2str->Str[locale] == nullStr)
 if (char* str = AddString(&db2str->Str[locale], fields[1 + stringFieldNumInRecord].GetString()))
 stringPool.push_back(str);

 ++stringFieldNumInRecord;
 offset += sizeof(char*);
 break;
 }
 }
 }

 ASSERT(offset == recordSize);
 }
 else
 TC_LOG_ERROR("sql.sql", "Hotfix locale table for storage %s references row that does not exist %u!", _storageName.c_str(), indexValue);

 } while (result->NextRow());

 return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::string DB2DatabaseLoader::_storageName

private

---

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

• src/server/shared/DataStores/DB2StorageLoader.h
• src/server/shared/DataStores/DB2StorageLoader.cpp