diff --git a/src/shared/Database/DBCFileLoader.cpp b/src/shared/Database/DBCFileLoader.cpp
index 475fafa1b..8cd88bf63 100644
--- a/src/shared/Database/DBCFileLoader.cpp
+++ b/src/shared/Database/DBCFileLoader.cpp
@@ -107,29 +107,42 @@ uint32 DBCFileLoader::GetFormatRecordSize(const char * format,int32* index_pos)
 {
     uint32 recordsize = 0;
     int32 i = -1;
-    for(uint32 x=0; format[x];++x)
+    for(uint32 x = 0; format[x]; ++ x)
+    {
         switch(format[x])
         {
             case FT_FLOAT:
+                recordsize += sizeof(float);
+                break;
             case FT_INT:
-                recordsize+=4;
+                recordsize += sizeof(uint32);
                 break;
             case FT_STRING:
-                recordsize+=sizeof(char*);
+                recordsize += sizeof(char*);
                 break;
             case FT_SORT:
                 i=x;
                 break;
             case FT_IND:
                 i=x;
-                recordsize+=4;
+                recordsize += sizeof(uint32);
                 break;
             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;
         }
+    }
 
-    if(index_pos)
+    if (index_pos)
         *index_pos = i;
 
     return recordsize;
@@ -181,35 +194,45 @@ char* DBCFileLoader::AutoProduceData(const char* format, uint32& records, char**
 
     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];
         }
         else
             indexTable[y]=&dataTable[offset];
 
-        for(uint32 x=0;x<fieldCount;x++)
+        for(uint32 x = 0; x < fieldCount; ++x)
         {
             switch(format[x])
             {
                 case FT_FLOAT:
                     *((float*)(&dataTable[offset]))=getRecord(y).getFloat(x);
-                    offset+=4;
+                    offset += sizeof(float);
                     break;
                 case FT_IND:
                 case FT_INT:
                     *((uint32*)(&dataTable[offset]))=getRecord(y).getUInt(x);
-                    offset+=4;
+                    offset += sizeof(uint32);
                     break;
                 case FT_BYTE:
                     *((uint8*)(&dataTable[offset]))=getRecord(y).getUInt8(x);
-                    offset+=1;
+                    offset += sizeof(uint8);
                     break;
                 case FT_STRING:
                     *((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;
             }
         }
@@ -228,37 +251,45 @@ char* DBCFileLoader::AutoProduceStrings(const char* format, char* dataTable)
 
     uint32 offset=0;
 
-    for(uint32 y =0;y<recordCount;y++)
+    for(uint32 y =0; y < recordCount; ++y)
     {
-        for(uint32 x=0;x<fieldCount;x++)
-            switch(format[x])
+        for(uint32 x = 0; x < fieldCount; ++x)
         {
-            case FT_FLOAT:
-            case FT_IND:
-            case FT_INT:
-                offset+=4;
-                break;
-            case FT_BYTE:
-                offset+=1;
-                break;
-            case FT_STRING:
+            switch(format[x])
             {
-                // fill only not filled entries
-                char** slot = (char**)(&dataTable[offset]);
-                if(!*slot || !**slot)
+                case FT_FLOAT:
+                    offset += sizeof(float);
+                    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);
-                    *slot=stringPool+(st-(const char*)stringTable);
+                    // fill only not filled entries
+                    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*);
-                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;
             }
-            case FT_NA:
-            case FT_NA_BYTE:
-            case FT_SORT:
-                break;
-            default:
-                assert(false && "unknown format character");
         }
     }
 
diff --git a/src/shared/Database/SQLStorage.cpp b/src/shared/Database/SQLStorage.cpp
index c33530b5d..63ff5e5e7 100644
--- a/src/shared/Database/SQLStorage.cpp
+++ b/src/shared/Database/SQLStorage.cpp
@@ -21,43 +21,79 @@
 
 void SQLStorage::EraseEntry(uint32 id)
 {
-    uint32 offset=0;
-    for(uint32 x=0;x<iNumFields;x++)
-        if (dst_format[x]==FT_STRING)
+    uint32 offset = 0;
+    for(uint32 x = 0; x < iNumFields; ++x)
+    {
+        switch(dst_format[x])
         {
-            if(pIndex[id])
-                delete [] *(char**)((char*)(pIndex[id])+offset);
+            case FT_LOGIC:
+                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;
 }
 
 void SQLStorage::Free ()
 {
-    uint32 offset=0;
-    for(uint32 x=0;x<iNumFields;x++)
-        if (dst_format[x]==FT_STRING)
+    uint32 offset = 0;
+    for(uint32 x = 0; x < iNumFields; ++x)
+    {
+        switch(dst_format[x])
         {
-            for(uint32 y=0;y<MaxEntry;y++)
-                if(pIndex[y])
-                    delete [] *(char**)((char*)(pIndex[y])+offset);
+            case FT_LOGIC:
+                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:
+            {
+                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 [] data;
diff --git a/src/shared/Database/SQLStorageImpl.h b/src/shared/Database/SQLStorageImpl.h
index cad684d19..62625c583 100644
--- a/src/shared/Database/SQLStorageImpl.h
+++ b/src/shared/Database/SQLStorageImpl.h
@@ -88,6 +88,16 @@ void SQLStorageLoaderBase<T>::storeValue(V value, SQLStorage &store, char *p, ui
             subclass->convert_to_str(x, value, *((char**)(&p[offset])) );
             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;
     }
 }
 
@@ -117,6 +127,16 @@ void SQLStorageLoaderBase<T>::storeValue(char const* value, SQLStorage &store, c
             subclass->convert_str_to_str(x, value, *((char**)(&p[offset])) );
             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;
     }
 }
 
@@ -172,17 +192,32 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store, bool error_at_empty /*= tr
     }
 
     //get struct size
-    uint32 sc=0;
-    uint32 bo=0;
-    uint32 bb=0;
-    for(uint32 x=0; x< store.iNumFields; x++)
-        if(store.dst_format[x]==FT_STRING)
-            ++sc;
-        else if (store.dst_format[x]==FT_LOGIC)
-            ++bo;
-        else if (store.dst_format[x]==FT_BYTE)
-            ++bb;
-    recordsize=(store.iNumFields-sc-bo-bb)*4+sc*sizeof(char*)+bo*sizeof(bool)+bb*sizeof(char);
+    for(uint32 x = 0; x < store.iNumFields; ++x)
+    {
+        switch(store.dst_format[x])
+        {
+            case FT_LOGIC:
+                recordsize += sizeof(bool);   break;
+            case FT_BYTE:
+                recordsize += sizeof(char);   break;
+            case FT_INT:
+                recordsize += sizeof(uint32); break;
+            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];
     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;
                 case FT_STRING:
                     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;
     }while( result->NextRow() );
diff --git a/src/shared/revision_nr.h b/src/shared/revision_nr.h
index 64ecdfe30..5a9f328f4 100644
--- a/src/shared/revision_nr.h
+++ b/src/shared/revision_nr.h
@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR "11247"
+ #define REVISION_NR "11248"
 #endif // __REVISION_NR_H__