mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-15 01:37:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[11248] Clarify and check DBC/SQL storage format field types.

Browse source 
Signed-off-by: VladimirMangos <vladimir@getmangos.com>
This commit is contained in:
Vinolentus 2011-03-15 02:53:59 +03:00 • committed by VladimirMangos
parent 189e7c08b7
commit a6bab82c72
4 changed files with 186 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

107
src/shared/Database/DBCFileLoader.cpp
View file

@ -107,29 +107,42 @@ uint32 DBCFileLoader::GetFormatRecordSize(const char * format,int32* index_pos)
{ {
uint32 recordsize = 0; uint32 recordsize = 0;
int32 i = -1; int32 i = -1;
for(uint32 x=0; format[x];++x) for(uint32 x = 0; format[x]; ++ x)
{
switch(format[x]) switch(format[x])
{ {
case FT_FLOAT: case FT_FLOAT:
recordsize += sizeof(float);
break;
case FT_INT: case FT_INT:
recordsize+=4; recordsize += sizeof(uint32);
break; break;
case FT_STRING: case FT_STRING:
recordsize+=sizeof(char*); recordsize += sizeof(char*);
break; break;
case FT_SORT: case FT_SORT:
i=x; i=x;
break; break;
case FT_IND: case FT_IND:
i=x; i=x;
recordsize+=4; recordsize += sizeof(uint32);
break; break;
case FT_BYTE: case FT_BYTE:
recordsize += 1; recordsize += sizeof(uint8);
break;
case FT_LOGIC:
assert(false && "DBC files not have logic field type");
break;
case FT_NA:
case FT_NA_BYTE:
break;
default:
assert(false && "unknown format character");
break; break;
} }
}
if(index_pos) if (index_pos)
*index_pos = i; *index_pos = i;
return recordsize; return recordsize;
@ -181,35 +194,45 @@ char* DBCFileLoader::AutoProduceData(const char* format, uint32& records, char**
uint32 offset=0; uint32 offset=0;
for(uint32 y =0;y<recordCount;y++) for(uint32 y =0; y < recordCount; ++y)
{ {
if(i>=0) if (i >= 0)
{ {
indexTable[getRecord(y).getUInt(i)]=&dataTable[offset]; indexTable[getRecord(y).getUInt(i)]=&dataTable[offset];
} }
else else
indexTable[y]=&dataTable[offset]; indexTable[y]=&dataTable[offset];
for(uint32 x=0;x<fieldCount;x++) for(uint32 x = 0; x < fieldCount; ++x)
{ {
switch(format[x]) switch(format[x])
{ {
case FT_FLOAT: case FT_FLOAT:
*((float*)(&dataTable[offset]))=getRecord(y).getFloat(x); *((float*)(&dataTable[offset]))=getRecord(y).getFloat(x);
offset+=4; offset += sizeof(float);
break; break;
case FT_IND: case FT_IND:
case FT_INT: case FT_INT:
*((uint32*)(&dataTable[offset]))=getRecord(y).getUInt(x); *((uint32*)(&dataTable[offset]))=getRecord(y).getUInt(x);
offset+=4; offset += sizeof(uint32);
break; break;
case FT_BYTE: case FT_BYTE:
*((uint8*)(&dataTable[offset]))=getRecord(y).getUInt8(x); *((uint8*)(&dataTable[offset]))=getRecord(y).getUInt8(x);
offset+=1; offset += sizeof(uint8);
break; break;
case FT_STRING: case FT_STRING:
*((char**)(&dataTable[offset]))=NULL; // will be replaces non-empty or "" strings in AutoProduceStrings *((char**)(&dataTable[offset]))=NULL; // will be replaces non-empty or "" strings in AutoProduceStrings
offset+=sizeof(char*); offset += sizeof(char*);
break;
case FT_LOGIC:
assert(false && "DBC files not have logic field type");
break;
case FT_NA:
case FT_NA_BYTE:
case FT_SORT:
break;
default:
assert(false && "unknown format character");
break; break;
} }
} }
@ -228,37 +251,45 @@ char* DBCFileLoader::AutoProduceStrings(const char* format, char* dataTable)
uint32 offset=0; uint32 offset=0;
for(uint32 y =0;y<recordCount;y++) for(uint32 y =0; y < recordCount; ++y)
{ {
for(uint32 x=0;x<fieldCount;x++) for(uint32 x = 0; x < fieldCount; ++x)
switch(format[x])
{ {
case FT_FLOAT: switch(format[x])
case FT_IND:
case FT_INT:
offset+=4;
break;
case FT_BYTE:
offset+=1;
break;
case FT_STRING:
{ {
// fill only not filled entries case FT_FLOAT:
char** slot = (char**)(&dataTable[offset]); offset += sizeof(float);
if(!*slot || !**slot) break;
case FT_IND:
case FT_INT:
offset += sizeof(uint32);
break;
case FT_BYTE:
offset += sizeof(uint8);
break;
case FT_STRING:
{ {
const char * st = getRecord(y).getString(x); // fill only not filled entries
*slot=stringPool+(st-(const char*)stringTable); char** slot = (char**)(&dataTable[offset]);
if(!*slot || !**slot)
{
const char * st = getRecord(y).getString(x);
*slot=stringPool+(st-(const char*)stringTable);
}
offset += sizeof(char*);
break;
} }
offset+=sizeof(char*); case FT_LOGIC:
break; assert(false && "DBC files not have logic field type");
break;
case FT_NA:
case FT_NA_BYTE:
case FT_SORT:
break;
default:
assert(false && "unknown format character");
break;
} }
case FT_NA:
case FT_NA_BYTE:
case FT_SORT:
break;
default:
assert(false && "unknown format character");
} }
} }

86
src/shared/Database/SQLStorage.cpp
View file

@ -21,43 +21,79 @@
void SQLStorage::EraseEntry(uint32 id) void SQLStorage::EraseEntry(uint32 id)
{ {
uint32 offset=0; uint32 offset = 0;
for(uint32 x=0;x<iNumFields;x++) for(uint32 x = 0; x < iNumFields; ++x)
if (dst_format[x]==FT_STRING) {
switch(dst_format[x])
{ {
if(pIndex[id]) case FT_LOGIC:
delete [] *(char**)((char*)(pIndex[id])+offset); offset += sizeof(bool); break;
case FT_BYTE:
offset += sizeof(char); break;
case FT_INT:
offset += sizeof(uint32); break;
case FT_FLOAT:
offset += sizeof(float); break;
case FT_STRING:
{
if(pIndex[id])
delete [] *(char**)((char*)(pIndex[id])+offset);
offset += sizeof(char*); offset += sizeof(char*);
break;
}
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
break;
} }
else if (dst_format[x]==FT_LOGIC) }
offset += sizeof(bool);
else if (dst_format[x]==FT_BYTE)
offset += sizeof(char);
else
offset += 4;
pIndex[id] = NULL; pIndex[id] = NULL;
} }
void SQLStorage::Free () void SQLStorage::Free ()
{ {
uint32 offset=0; uint32 offset = 0;
for(uint32 x=0;x<iNumFields;x++) for(uint32 x = 0; x < iNumFields; ++x)
if (dst_format[x]==FT_STRING) {
switch(dst_format[x])
{ {
for(uint32 y=0;y<MaxEntry;y++) case FT_LOGIC:
if(pIndex[y]) offset += sizeof(bool); break;
delete [] *(char**)((char*)(pIndex[y])+offset); case FT_BYTE:
offset += sizeof(char); break;
case FT_INT:
offset += sizeof(uint32); break;
case FT_FLOAT:
offset += sizeof(float); break;
case FT_STRING:
{
for(uint32 y = 0; y < MaxEntry; ++y)
if(pIndex[y])
delete [] *(char**)((char*)(pIndex[y])+offset);
offset += sizeof(char*); offset += sizeof(char*);
break;
}
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
break;
} }
else if (dst_format[x]==FT_LOGIC) }
offset += sizeof(bool);
else if (dst_format[x]==FT_BYTE)
offset += sizeof(char);
else
offset += 4;
delete [] pIndex; delete [] pIndex;
delete [] data; delete [] data;

66
src/shared/Database/SQLStorageImpl.h
View file

@ -88,6 +88,16 @@ void SQLStorageLoaderBase<T>::storeValue(V value, SQLStorage &store, char *p, ui
subclass->convert_to_str(x, value, *((char**)(&p[offset])) ); subclass->convert_to_str(x, value, *((char**)(&p[offset])) );
offset+=sizeof(char*); offset+=sizeof(char*);
break; break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
break;
} }
} }
@ -117,6 +127,16 @@ void SQLStorageLoaderBase<T>::storeValue(char const* value, SQLStorage &store, c
subclass->convert_str_to_str(x, value, *((char**)(&p[offset])) ); subclass->convert_str_to_str(x, value, *((char**)(&p[offset])) );
offset+=sizeof(char*); offset+=sizeof(char*);
break; break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
break;
} }
} }
@ -172,17 +192,32 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store, bool error_at_empty /*= tr
} }
//get struct size //get struct size
uint32 sc=0; for(uint32 x = 0; x < store.iNumFields; ++x)
uint32 bo=0; {
uint32 bb=0; switch(store.dst_format[x])
for(uint32 x=0; x< store.iNumFields; x++) {
if(store.dst_format[x]==FT_STRING) case FT_LOGIC:
++sc; recordsize += sizeof(bool); break;
else if (store.dst_format[x]==FT_LOGIC) case FT_BYTE:
++bo; recordsize += sizeof(char); break;
else if (store.dst_format[x]==FT_BYTE) case FT_INT:
++bb; recordsize += sizeof(uint32); break;
recordsize=(store.iNumFields-sc-bo-bb)*4+sc*sizeof(char*)+bo*sizeof(bool)+bb*sizeof(char); case FT_FLOAT:
recordsize += sizeof(float); break;
case FT_STRING:
recordsize += sizeof(char*); break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
break;
}
}
char** newIndex=new char*[maxi]; char** newIndex=new char*[maxi];
memset(newIndex,0,maxi*sizeof(char*)); memset(newIndex,0,maxi*sizeof(char*));
@ -211,6 +246,15 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store, bool error_at_empty /*= tr
storeValue((float)fields[x].GetFloat(), store, p, x, offset); break; storeValue((float)fields[x].GetFloat(), store, p, x, offset); break;
case FT_STRING: case FT_STRING:
storeValue((char const*)fields[x].GetString(), store, p, x, offset); break; storeValue((char const*)fields[x].GetString(), store, p, x, offset); break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage not have sort field types");
break;
default:
assert(false && "unknown format character");
} }
++count; ++count;
}while( result->NextRow() ); }while( result->NextRow() );

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__ #ifndef __REVISION_NR_H__
#define __REVISION_NR_H__ #define __REVISION_NR_H__
#define REVISION_NR "11247" #define REVISION_NR "11248"
#endif // __REVISION_NR_H__ #endif // __REVISION_NR_H__