Core/DataStores: Updated opcodes and db2 to 7.0.3.21414

7 files changed, 50 insertions, 785 deletions

diff --git a/src/server/shared/DataStores/DB2SparseStorageLoader.cpp b/src/server/shared/DataStores/DB2SparseStorageLoader.cpp
index 42914b4da17..2d5c11b9d5d 100644
--- a/src/server/shared/DataStores/DB2SparseStorageLoader.cpp
+++ b/src/server/shared/DataStores/DB2SparseStorageLoader.cpp
@@ -17,7 +17,7 @@
 
 #include "Common.h"
 #include "DB2SparseStorageLoader.h"
-#include "Database/DatabaseEnv.h"
+#include "DatabaseEnv.h"
 #include "Log.h"
 
 DB2SparseFileLoader::DB2SparseFileLoader()
@@ -201,6 +201,7 @@ uint32 DB2SparseFileLoader::GetFormatRecordSize(const char * format)
         {
             case FT_FLOAT:
             case FT_INT:
+            case FT_SORT:
                 recordsize += 4;
                 break;
             case FT_STRING:
@@ -247,7 +248,7 @@ static char const* const nullStr = "";
 char* DB2SparseFileLoader::AutoProduceData(const char* format, IndexTable const& indexTable, uint32 locale, std::vector<char*>& stringPool)
 {
     typedef char* ptr;
-    if (strlen(format) != fieldCount)
+    if (strlen(format) != fieldCount + (format[0] == FT_SORT ? 1 : 0))
         return NULL;
 
     //get struct size and index pos
@@ -283,8 +284,8 @@ char* DB2SparseFileLoader::AutoProduceData(const char* format, IndexTable const&
     for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i)
         ((char const**)stringHoldersPool)[i] = nullStr;
 
-    char* stringTable = new char[expandedDataSize - records * (recordsize - stringFields * sizeof(char*))];
-    memset(stringTable, 0, expandedDataSize - records * (recordsize - stringFields * sizeof(char*)));
+    char* stringTable = new char[expandedDataSize - records * ((recordsize - (format[0] == FT_SORT ? 4 : 0)) - stringFields * sizeof(char*))];
+    memset(stringTable, 0, expandedDataSize - records * ((recordsize - (format[0] == FT_SORT ? 4 : 0)) - stringFields * sizeof(char*)));
     stringPool.push_back(stringTable);
     char* stringPtr = stringTable;
 
@@ -298,7 +299,7 @@ char* DB2SparseFileLoader::AutoProduceData(const char* format, IndexTable const&
         indexTable.Insert(y + minIndex, &dataTable[offset]);
         uint32 fieldOffset = 0;
         uint32 stringFieldOffset = 0;
-        for (uint32 x = 0; x < fieldCount; x++)
+        for (uint32 x = 0; x < (fieldCount + (format[0] == FT_SORT ? 1 : 0)); x++)
         {
             switch (format[x])
             {
@@ -352,6 +353,10 @@ char* DB2SparseFileLoader::AutoProduceData(const char* format, IndexTable const&
                     offset += sizeof(char*);
                     break;
                 }
+                case FT_SORT:
+                    *((uint32*)(&dataTable[offset])) = y + minIndex;
+                    offset += 4;
+                    break;
             }
         }
 
@@ -363,7 +368,7 @@ char* DB2SparseFileLoader::AutoProduceData(const char* format, IndexTable const&
 
 char* DB2SparseFileLoader::AutoProduceStrings(const char* format, char* dataTable, uint32 locale)
 {
-    if (strlen(format) != fieldCount)
+    if (strlen(format) != fieldCount + (format[0] == FT_SORT ? 1 : 0))
         return nullptr;
 
     if (!(localeMask & (1 << locale)))
@@ -513,6 +518,7 @@ char* DB2SparseDatabaseLoader::Load(const char* format, HotfixDatabaseStatements
                     break;
                 case FT_IND:
                 case FT_INT:
+                case FT_SORT:
                     *((int32*)(&dataValue[offset])) = fields[f].GetInt32();
                     offset += 4;
                     break;
@@ -617,6 +623,7 @@ void DB2SparseDatabaseLoader::LoadStrings(const char* format, HotfixDatabaseStat
                     case FT_FLOAT:
                     case FT_IND:
                     case FT_INT:
+                    case FT_SORT:
                         offset += 4;
                         break;
                     case FT_BYTE:
diff --git a/src/server/shared/DataStores/DB2StorageLoader.cpp b/src/server/shared/DataStores/DB2StorageLoader.cpp
index d101d12a52e..56a8dbbed65 100644
--- a/src/server/shared/DataStores/DB2StorageLoader.cpp
+++ b/src/server/shared/DataStores/DB2StorageLoader.cpp
@@ -253,8 +253,6 @@ uint32 DB2FileLoader::GetFormatRecordSize(const char * format, int32* index_pos)
                 recordsize += sizeof(char*);
                 break;
             case FT_SORT:
-                i = x;
-                break;
             case FT_IND:
                 i = x;
                 recordsize += 4;
@@ -322,7 +320,6 @@ char* DB2FileLoader::AutoProduceData(const char* format, uint32& records, char**
         }
         else
         {
-            ASSERT(indexField == 0);
             for (uint32 y = 0; y < recordCount; ++y)
             {
                 uint32 ind = ((uint32*)idTable)[y];
@@ -353,48 +350,51 @@ char* DB2FileLoader::AutoProduceData(const char* format, uint32& records, char**
 
     uint32 offset = 0;
 
-    if (idTableSize)
-    {
-        ASSERT(format[0] == 'd');
-        ++format;
-    }
-
     for (uint32 y = 0; y < recordCount; y++)
     {
+        uint32 indexVal;
         if (indexField >= 0)
-            indexTable[!idTableSize ? getRecord(y).getUInt(indexField) : ((uint32*)idTable)[y]] = &dataTable[offset];
+            indexVal = !idTableSize ? getRecord(y).getUInt(indexField) : ((uint32*)idTable)[y];
         else
-            indexTable[y] = &dataTable[offset];
+            indexVal = y;
 
-        for (uint32 x = 0; x < fieldCount; x++)
+        indexTable[indexVal] = &dataTable[offset];
+
+        uint32 x = 0;
+        for (char const* fmt = format; *fmt != '\0'; ++fmt)
         {
-            switch (format[x])
+            switch (*fmt)
             {
                 case FT_FLOAT:
-                    *((float*)(&dataTable[offset])) = getRecord(y).getFloat(x);
+                    *((float*)(&dataTable[offset])) = getRecord(y).getFloat(x++);
                     offset += 4;
                     break;
                 case FT_IND:
                 case FT_INT:
-                    *((uint32*)(&dataTable[offset])) = getRecord(y).getUInt(x);
+                    *((uint32*)(&dataTable[offset])) = getRecord(y).getUInt(x++);
                     offset += 4;
                     break;
                 case FT_BYTE:
-                    *((uint8*)(&dataTable[offset])) = getRecord(y).getUInt8(x);
+                    *((uint8*)(&dataTable[offset])) = getRecord(y).getUInt8(x++);
                     offset += 1;
                     break;
                 case FT_LONG:
-                    *((uint64*)(&dataTable[offset])) = getRecord(y).getUInt64(x);
+                    *((uint64*)(&dataTable[offset])) = getRecord(y).getUInt64(x++);
                     offset += 8;
                     break;
                 case FT_SHORT:
-                    *((uint16*)(&dataTable[offset])) = getRecord(y).getUInt16(x);
+                    *((uint16*)(&dataTable[offset])) = getRecord(y).getUInt16(x++);
                     offset += 2;
                     break;
                 case FT_STRING:
                 case FT_STRING_NOT_LOCALIZED:
                     *((char**)(&dataTable[offset])) = nullptr;   // will be replaces non-empty or "" strings in AutoProduceStrings
                     offset += sizeof(char*);
+                    ++x;
+                    break;
+                case FT_SORT:
+                    *((uint32*)(&dataTable[offset])) = indexVal;
+                    offset += 4;
                     break;
             }
         }
@@ -444,21 +444,19 @@ char* DB2FileLoader::AutoProduceStringsArrayHolders(const char* format, char* da
 
     uint32 offset = 0;
 
-    if (idTableSize)
-        ++format;
-
     // assign string holders to string field slots
     for (uint32 y = 0; y < recordCount; y++)
     {
         uint32 stringFieldOffset = 0;
 
-        for (uint32 x = 0; x < fieldCount; x++)
+        for (char const* fmt = format; *fmt != '\0'; ++fmt)
         {
-            switch (format[x])
+            switch (*fmt)
             {
                 case FT_FLOAT:
                 case FT_IND:
                 case FT_INT:
+                case FT_SORT:
                     offset += 4;
                     break;
                 case FT_BYTE:
@@ -476,7 +474,7 @@ char* DB2FileLoader::AutoProduceStringsArrayHolders(const char* format, char* da
                     // init db2 string field slots by pointers to string holders
                     char const*** slot = (char const***)(&dataTable[offset]);
                     *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * y + stringFieldOffset]);
-                    if (format[x] == FT_STRING)
+                    if (*fmt == FT_STRING)
                         stringFieldOffset += stringHolderSize;
                     else
                         ++stringFieldOffset;
@@ -485,7 +483,7 @@ char* DB2FileLoader::AutoProduceStringsArrayHolders(const char* format, char* da
                     break;
                 }
                 default:
-                    ASSERT(false, "unknown format character %c", format[x]);
+                    ASSERT(false, "unknown format character %c", *fmt);
             }
         }
     }
@@ -521,18 +519,17 @@ char* DB2FileLoader::AutoProduceStrings(const char* format, char* dataTable, uin
 
     uint32 offset = 0;
 
-    if (idTableSize)
-        ++format;
-
     for (uint32 y = 0; y < recordCount; y++)
     {
-        for (uint32 x = 0; x < fieldCount; x++)
+        uint32 x = 0;
+        for (char const* fmt = format; *fmt != '\0'; ++fmt)
         {
-            switch (format[x])
+            switch (*fmt)
             {
                 case FT_FLOAT:
                 case FT_IND:
                 case FT_INT:
+                case FT_SORT:
                     offset += 4;
                     break;
                 case FT_BYTE:
@@ -566,6 +563,9 @@ char* DB2FileLoader::AutoProduceStrings(const char* format, char* dataTable, uin
                     break;
                 }
             }
+
+            if (*fmt != FT_SORT)
+                ++x;
         }
     }
 
@@ -705,6 +705,10 @@ char* DB2DatabaseLoader::Load(const char* format, HotfixDatabaseStatements prepa
                     offset += sizeof(char*);
                     break;
                 }
+                case FT_SORT:
+                    *((int32*)(&dataValue[offset])) = indexValue;
+                    offset += 4;
+                    break;
             }
         }
 
@@ -769,6 +773,7 @@ void DB2DatabaseLoader::LoadStrings(const char* format, HotfixDatabaseStatements
                     case FT_FLOAT:
                     case FT_IND:
                     case FT_INT:
+                    case FT_SORT:
                         offset += 4;
                         break;
                     case FT_BYTE:
diff --git a/src/server/shared/DataStores/DB2Store.h b/src/server/shared/DataStores/DB2Store.h
index d1542faa194..e1c05cfbbe7 100644
--- a/src/server/shared/DataStores/DB2Store.h
+++ b/src/server/shared/DataStores/DB2Store.h
@@ -245,8 +245,8 @@ public:
         iterator_wrapper(iterator_wrapper const& right) = default;
         iterator_wrapper(Base const& baseItr) : Base(baseItr) { }
 
-        uint32 ID() const { return (*this)->first; }
-        T const* Data() const { return (*this)->second; }
+        T const* operator->() const { return Base::operator->()->second; }
+        T const* operator*() const { return Base::operator*().second; }
     } iterator;
 
     DB2SparseStorage(char const* fileName, char const* format, HotfixDatabaseStatements preparedStmtIndex)
diff --git a/src/server/shared/DataStores/DBCFileLoader.cpp b/src/server/shared/DataStores/DBCFileLoader.cpp
deleted file mode 100644
index ace59bb9ebb..00000000000
--- a/src/server/shared/DataStores/DBCFileLoader.cpp
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "DBCFileLoader.h"
-#include "Errors.h"
-
-DBCFileLoader::DBCFileLoader() : recordSize(0), recordCount(0), fieldCount(0), stringSize(0), fieldsOffset(NULL), data(NULL), stringTable(NULL) { }
-
-bool DBCFileLoader::Load(const char* filename, const char* fmt)
-{
-    uint32 header;
-    if (data)
-    {
-        delete [] data;
-        data = NULL;
-    }
-
-    FILE* f = fopen(filename, "rb");
-    if (!f)
-        return false;
-
-    if (fread(&header, 4, 1, f) != 1)                        // Number of records
-    {
-        fclose(f);
-        return false;
-    }
-
-
-    EndianConvert(header);
-
-    if (header != 0x43424457)                                //'WDBC'
-    {
-        fclose(f);
-        return false;
-    }
-
-    if (fread(&recordCount, 4, 1, f) != 1)                   // Number of records
-    {
-        fclose(f);
-        return false;
-    }
-
-    EndianConvert(recordCount);
-
-    if (fread(&fieldCount, 4, 1, f) != 1)                    // Number of fields
-    {
-        fclose(f);
-        return false;
-    }
-
-    EndianConvert(fieldCount);
-
-    if (fread(&recordSize, 4, 1, f) != 1)                    // Size of a record
-    {
-        fclose(f);
-        return false;
-    }
-
-    EndianConvert(recordSize);
-
-    if (fread(&stringSize, 4, 1, f) != 1)                    // String size
-    {
-        fclose(f);
-        return false;
-    }
-
-    EndianConvert(stringSize);
-
-    fieldsOffset = new uint32[fieldCount];
-    fieldsOffset[0] = 0;
-    for (uint32 i = 1; i < fieldCount; ++i)
-    {
-        fieldsOffset[i] = fieldsOffset[i - 1];
-        if (fmt[i - 1] == FT_BYTE || fmt[i - 1] == FT_NA_BYTE)  // byte fields
-            fieldsOffset[i] += sizeof(uint8);
-        else if (fmt[i - 1] == FT_LONG)
-            fieldsOffset[i] += sizeof(uint64);
-        else                                                // 4 byte fields (int32/float/strings)
-            fieldsOffset[i] += sizeof(uint32);
-    }
-
-    data = new unsigned char[recordSize * recordCount + stringSize];
-    stringTable = data + recordSize*recordCount;
-
-    if (fread(data, recordSize * recordCount + stringSize, 1, f) != 1)
-    {
-        fclose(f);
-        return false;
-    }
-
-    fclose(f);
-
-    return true;
-}
-
-DBCFileLoader::~DBCFileLoader()
-{
-    delete[] data;
-
-    delete[] fieldsOffset;
-}
-
-DBCFileLoader::Record DBCFileLoader::getRecord(size_t id)
-{
-    assert(data);
-    return Record(*this, data + id * recordSize);
-}
-
-uint32 DBCFileLoader::GetFormatRecordSize(const char* format, int32* index_pos)
-{
-    uint32 recordsize = 0;
-    int32 i = -1;
-    for (uint32 x = 0; format[x]; ++x)
-    {
-        switch (format[x])
-        {
-            case FT_FLOAT:
-                recordsize += sizeof(float);
-                break;
-            case FT_INT:
-                recordsize += sizeof(uint32);
-                break;
-            case FT_STRING:
-                recordsize += sizeof(char*);
-                break;
-            case FT_SORT:
-                i = x;
-                break;
-            case FT_IND:
-                i = x;
-                recordsize += sizeof(uint32);
-                break;
-            case FT_BYTE:
-                recordsize += sizeof(uint8);
-                break;
-            case FT_LONG:
-                recordsize += sizeof(uint64);
-                break;
-            case FT_NA:
-            case FT_NA_BYTE:
-                break;
-            default:
-                ASSERT(false && "Unknown field format character in DBCfmt.h");
-                break;
-        }
-    }
-
-    if (index_pos)
-        *index_pos = i;
-
-    return recordsize;
-}
-
-char* DBCFileLoader::AutoProduceData(const char* format, uint32& records, char**& indexTable, uint32 sqlRecordCount, uint32 sqlHighestIndex, char*& sqlDataTable)
-{
-    typedef char* ptr;
-    if (strlen(format) != fieldCount)
-        return NULL;
-
-    //get struct size and index pos
-    int32 i;
-    uint32 recordsize = GetFormatRecordSize(format, &i);
-
-    if (i >= 0)
-    {
-        uint32 maxi = 0;
-        //find max index
-        for (uint32 y = 0; y < recordCount; ++y)
-        {
-            uint32 ind = getRecord(y).getUInt(i);
-            if (ind > maxi)
-                maxi = ind;
-        }
-
-        // If higher index avalible from sql - use it instead of dbcs
-        if (sqlHighestIndex > maxi)
-            maxi = sqlHighestIndex;
-
-        ++maxi;
-        records = maxi;
-        indexTable = new ptr[maxi];
-        memset(indexTable, 0, maxi * sizeof(ptr));
-    }
-    else
-    {
-        records = recordCount + sqlRecordCount;
-        indexTable = new ptr[recordCount + sqlRecordCount];
-    }
-
-    char* dataTable = new char[(recordCount + sqlRecordCount) * recordsize];
-
-    uint32 offset = 0;
-
-    for (uint32 y = 0; y < recordCount; ++y)
-    {
-        if (i >= 0)
-            indexTable[getRecord(y).getUInt(i)] = &dataTable[offset];
-        else
-            indexTable[y] = &dataTable[offset];
-
-        for (uint32 x=0; x < fieldCount; ++x)
-        {
-            switch (format[x])
-            {
-                case FT_FLOAT:
-                    *((float*)(&dataTable[offset])) = getRecord(y).getFloat(x);
-                    offset += sizeof(float);
-                    break;
-                case FT_IND:
-                case FT_INT:
-                    *((uint32*)(&dataTable[offset])) = getRecord(y).getUInt(x);
-                    offset += sizeof(uint32);
-                    break;
-                case FT_BYTE:
-                    *((uint8*)(&dataTable[offset])) = getRecord(y).getUInt8(x);
-                    offset += sizeof(uint8);
-                    break;
-                case FT_LONG:
-                    *((uint64*)(&dataTable[offset])) = getRecord(y).getUInt64(x);
-                    offset += sizeof(uint64);
-                    break;
-                case FT_STRING:
-                    *((char**)(&dataTable[offset])) = NULL;   // will replace non-empty or "" strings in AutoProduceStrings
-                    offset += sizeof(char*);
-                    break;
-                case FT_NA:
-                case FT_NA_BYTE:
-                case FT_SORT:
-                    break;
-                default:
-                    ASSERT(false && "Unknown field format character in DBCfmt.h");
-                    break;
-            }
-        }
-    }
-
-    sqlDataTable = dataTable + offset;
-
-    return dataTable;
-}
-
-char* DBCFileLoader::AutoProduceStrings(const char* format, char* dataTable)
-{
-    if (strlen(format) != fieldCount)
-        return NULL;
-
-    char* stringPool = new char[stringSize];
-    memcpy(stringPool, stringTable, stringSize);
-
-    uint32 offset = 0;
-
-    for (uint32 y = 0; y < recordCount; ++y)
-    {
-        for (uint32 x = 0; x < fieldCount; ++x)
-        {
-            switch (format[x])
-            {
-                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_LONG:
-                    offset += sizeof(uint64);
-                    break;
-                case FT_STRING:
-                {
-                    // 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;
-                 }
-                 case FT_NA:
-                 case FT_NA_BYTE:
-                 case FT_SORT:
-                     break;
-                 default:
-                     ASSERT(false && "Unknown field format character in DBCfmt.h");
-                     break;
-            }
-        }
-    }
-
-    return stringPool;
-}
diff --git a/src/server/shared/DataStores/DBCFileLoader.h b/src/server/shared/DataStores/DBCFileLoader.h
deleted file mode 100644
index e58031e6ccc..00000000000
--- a/src/server/shared/DataStores/DBCFileLoader.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef DBC_FILE_LOADER_H
-#define DBC_FILE_LOADER_H
-
-#include "Define.h"
-#include "Utilities/ByteConverter.h"
-#include <cassert>
-
-class TC_SHARED_API DBCFileLoader
-{
-    public:
-        DBCFileLoader();
-        ~DBCFileLoader();
-
-        bool Load(const char *filename, const char *fmt);
-
-        class Record
-        {
-            public:
-                float getFloat(size_t field) const
-                {
-                    assert(field < file.fieldCount);
-                    float val = *reinterpret_cast<float*>(offset + file.GetOffset(field));
-                    EndianConvert(val);
-                    return val;
-                }
-                uint32 getUInt(size_t field) const
-                {
-                    assert(field < file.fieldCount);
-                    uint32 val = *reinterpret_cast<uint32*>(offset + file.GetOffset(field));
-                    EndianConvert(val);
-                    return val;
-                }
-                uint8 getUInt8(size_t field) const
-                {
-                    assert(field < file.fieldCount);
-                    return *reinterpret_cast<uint8*>(offset + file.GetOffset(field));
-                }
-                uint64 getUInt64(size_t field) const
-                {
-                    assert(field < file.fieldCount);
-                    uint64 val = *reinterpret_cast<uint64*>(offset + file.GetOffset(field));
-                    EndianConvert(val);
-                    return val;
-                }
-                const char *getString(size_t field) const
-                {
-                    assert(field < file.fieldCount);
-                    size_t stringOffset = getUInt(field);
-                    assert(stringOffset < file.stringSize);
-                    return reinterpret_cast<char*>(file.stringTable + stringOffset);
-                }
-
-            private:
-                Record(DBCFileLoader &file_, unsigned char *offset_): offset(offset_), file(file_) { }
-                unsigned char* offset;
-                DBCFileLoader& file;
-
-                friend class DBCFileLoader;
-
-        };
-
-        // Get record by id
-        Record getRecord(size_t id);
-        /// Get begin iterator over records
-
-        uint32 GetNumRows() const { return recordCount; }
-        uint32 GetRowSize() const { return recordSize; }
-        uint32 GetCols() const { return fieldCount; }
-        uint32 GetOffset(size_t id) const { return (fieldsOffset != NULL && id < fieldCount) ? fieldsOffset[id] : 0; }
-        bool IsLoaded() const { return data != NULL; }
-        char* AutoProduceData(const char* fmt, uint32& count, char**& indexTable, uint32 sqlRecordCount, uint32 sqlHighestIndex, char *& sqlDataTable);
-        char* AutoProduceStrings(const char* fmt, char* dataTable);
-        static uint32 GetFormatRecordSize(const char * format, int32 * index_pos = NULL);
-    private:
-
-        uint32 recordSize;
-        uint32 recordCount;
-        uint32 fieldCount;
-        uint32 stringSize;
-        uint32 *fieldsOffset;
-        unsigned char *data;
-        unsigned char *stringTable;
-
-        DBCFileLoader(DBCFileLoader const& right) = delete;
-        DBCFileLoader& operator=(DBCFileLoader const& right) = delete;
-};
-#endif
diff --git a/src/server/shared/DataStores/DBCStore.h b/src/server/shared/DataStores/DBCStore.h
deleted file mode 100644
index c53d2a563fe..00000000000
--- a/src/server/shared/DataStores/DBCStore.h
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef DBCSTORE_H
-#define DBCSTORE_H
-
-#include "DBCFileLoader.h"
-#include "DBStorageIterator.h"
-#include "Log.h"
-#include "Field.h"
-#include "DatabaseWorkerPool.h"
-#include "Implementation/WorldDatabase.h"
-#include "DatabaseEnv.h"
-
-struct SqlDbc
-{
-    std::string const* formatString;
-    std::string const* indexName;
-    std::string sqlTableName;
-    int32 indexPos;
-    int32 sqlIndexPos;
-    SqlDbc(std::string const* _filename, std::string const* _format, std::string const* _idname, char const* fmt)
-        : formatString(_format), indexName (_idname), sqlIndexPos(0)
-    {
-        // Convert dbc file name to sql table name
-        sqlTableName = *_filename;
-        for (uint32 i = 0; i< sqlTableName.size(); ++i)
-        {
-            if (isalpha(sqlTableName[i]))
-                sqlTableName[i] = char(tolower(sqlTableName[i]));
-            else if (sqlTableName[i] == '.')
-                sqlTableName[i] = '_';
-        }
-
-        // Get sql index position
-        DBCFileLoader::GetFormatRecordSize(fmt, &indexPos);
-        if (indexPos >= 0)
-        {
-            uint32 uindexPos = uint32(indexPos);
-            for (uint32 x = 0; x < formatString->size(); ++x)
-            {
-                // Count only fields present in sql
-                if ((*formatString)[x] == FT_SQL_PRESENT)
-                {
-                    if (x == uindexPos)
-                        break;
-                    ++sqlIndexPos;
-                }
-            }
-        }
-    }
-
-private:
-    SqlDbc(SqlDbc const& right) = delete;
-    SqlDbc& operator=(SqlDbc const& right) = delete;
-};
-
-template<class T>
-class DBCStorage
-{
-        typedef std::list<char*> StringPoolList;
-
-    public:
-        typedef DBStorageIterator<T> iterator;
-
-        explicit DBCStorage(char const* f)
-            : fmt(f), nCount(0), fieldCount(0), dataTable(NULL)
-        {
-            indexTable.asT = NULL;
-        }
-
-        ~DBCStorage() { Clear(); }
-
-        T const* LookupEntry(uint32 id) const
-        {
-            return (id >= nCount) ? NULL : indexTable.asT[id];
-        }
-
-        T const* AssertEntry(uint32 id) const
-        {
-            T const* entry = LookupEntry(id);
-            ASSERT(entry);
-            return entry;
-        }
-
-        uint32  GetNumRows() const { return nCount; }
-        char const* GetFormat() const { return fmt; }
-        uint32 GetFieldCount() const { return fieldCount; }
-
-        bool Load(char const* fn, SqlDbc* sql)
-        {
-            DBCFileLoader dbc;
-            // Check if load was successful, only then continue
-            if (!dbc.Load(fn, fmt))
-                return false;
-
-            uint32 sqlRecordCount = 0;
-            uint32 sqlHighestIndex = 0;
-            Field* fields = NULL;
-            QueryResult result = QueryResult(NULL);
-            // Load data from sql
-            if (sql)
-            {
-                std::string query = "SELECT * FROM " + sql->sqlTableName;
-                if (sql->indexPos >= 0)
-                    query +=" ORDER BY " + *sql->indexName + " DESC";
-                query += ';';
-
-
-                result = WorldDatabase.Query(query.c_str());
-                if (result)
-                {
-                    sqlRecordCount = uint32(result->GetRowCount());
-                    if (sql->indexPos >= 0)
-                    {
-                        fields = result->Fetch();
-                        sqlHighestIndex = fields[sql->sqlIndexPos].GetUInt32();
-                    }
-
-                    // Check if sql index pos is valid
-                    if (int32(result->GetFieldCount() - 1) < sql->sqlIndexPos)
-                    {
-                        TC_LOG_ERROR("server.loading", "Invalid index pos for dbc:'%s'", sql->sqlTableName.c_str());
-                        return false;
-                    }
-                }
-            }
-
-            char* sqlDataTable = NULL;
-            fieldCount = dbc.GetCols();
-
-            dataTable = reinterpret_cast<T*>(dbc.AutoProduceData(fmt, nCount, indexTable.asChar,
-                sqlRecordCount, sqlHighestIndex, sqlDataTable));
-
-            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, reinterpret_cast<char*>(dataTable)));
-
-            // Insert sql data into arrays
-            if (result)
-            {
-                if (indexTable.asT)
-                {
-                    uint32 offset = 0;
-                    uint32 rowIndex = dbc.GetNumRows();
-                    do
-                    {
-                        if (!fields)
-                            fields = result->Fetch();
-
-                        if (sql->indexPos >= 0)
-                        {
-                            uint32 id = fields[sql->sqlIndexPos].GetUInt32();
-                            if (indexTable.asT[id])
-                            {
-                                TC_LOG_ERROR("server.loading", "Index %d already exists in dbc:'%s'", id, sql->sqlTableName.c_str());
-                                return false;
-                            }
-
-                            indexTable.asT[id] = reinterpret_cast<T*>(&sqlDataTable[offset]);
-                        }
-                        else
-                            indexTable.asT[rowIndex]= reinterpret_cast<T*>(&sqlDataTable[offset]);
-
-                        uint32 columnNumber = 0;
-                        uint32 sqlColumnNumber = 0;
-
-                        for (; columnNumber < sql->formatString->size(); ++columnNumber)
-                        {
-                            if ((*sql->formatString)[columnNumber] == FT_SQL_ABSENT)
-                            {
-                                switch (fmt[columnNumber])
-                                {
-                                    case FT_FLOAT:
-                                        *reinterpret_cast<float*>(&sqlDataTable[offset]) = 0.0f;
-                                        offset += 4;
-                                        break;
-                                    case FT_IND:
-                                    case FT_INT:
-                                        *reinterpret_cast<uint32*>(&sqlDataTable[offset]) = uint32(0);
-                                        offset += 4;
-                                        break;
-                                    case FT_BYTE:
-                                        *reinterpret_cast<uint8*>(&sqlDataTable[offset]) = uint8(0);
-                                        offset += 1;
-                                        break;
-                                    case FT_LONG:
-                                        *reinterpret_cast<uint64*>(&sqlDataTable[offset]) = uint64(0);
-                                        offset += 8;
-                                        break;
-                                    case FT_STRING:
-                                        // Beginning of the pool - empty string
-                                        *reinterpret_cast<char**>(&sqlDataTable[offset]) = stringPoolList.back();
-                                        offset += sizeof(char*);
-                                        break;
-                                }
-                            }
-                            else if ((*sql->formatString)[columnNumber] == FT_SQL_PRESENT)
-                            {
-                                bool validSqlColumn = true;
-                                switch (fmt[columnNumber])
-                                {
-                                    case FT_FLOAT:
-                                        *reinterpret_cast<float*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetFloat();
-                                        offset += 4;
-                                        break;
-                                    case FT_IND:
-                                    case FT_INT:
-                                        *reinterpret_cast<uint32*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetUInt32();
-                                        offset += 4;
-                                        break;
-                                    case FT_BYTE:
-                                        *reinterpret_cast<uint8*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetUInt8();
-                                        offset += 1;
-                                        break;
-                                    case FT_LONG:
-                                        *reinterpret_cast<uint64*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetUInt64();
-                                        offset += 8;
-                                        break;
-                                    case FT_STRING:
-                                        TC_LOG_ERROR("server.loading", "Unsupported data type in table '%s' at char %d", sql->sqlTableName.c_str(), columnNumber);
-                                        return false;
-                                    case FT_SORT:
-                                        break;
-                                    default:
-                                        validSqlColumn = false;
-                                        break;
-                                }
-                                if (validSqlColumn && (columnNumber != (sql->formatString->size()-1)))
-                                    sqlColumnNumber++;
-                            }
-                            else
-                            {
-                                TC_LOG_ERROR("server.loading", "Incorrect sql format string '%s' at char %d", sql->sqlTableName.c_str(), columnNumber);
-                                return false;
-                            }
-                        }
-
-                        if (sqlColumnNumber != (result->GetFieldCount() - 1))
-                        {
-                            TC_LOG_ERROR("server.loading", "SQL and DBC format strings are not matching for table: '%s'", sql->sqlTableName.c_str());
-                            return false;
-                        }
-
-                        fields = NULL;
-                        ++rowIndex;
-                    } while (result->NextRow());
-                }
-            }
-
-            // error in dbc file at loading if NULL
-            return indexTable.asT != NULL;
-        }
-
-        bool LoadStringsFrom(char const* fn)
-        {
-            // DBC must be already loaded using Load
-            if (!indexTable.asT)
-                return false;
-
-            DBCFileLoader dbc;
-            // Check if load was successful, only then continue
-            if (!dbc.Load(fn, fmt))
-                return false;
-
-            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, reinterpret_cast<char*>(dataTable)));
-
-            return true;
-        }
-
-        void Clear()
-        {
-            if (!indexTable.asT)
-                return;
-
-            delete[] reinterpret_cast<char*>(indexTable.asT);
-            indexTable.asT = NULL;
-            delete[] reinterpret_cast<char*>(dataTable);
-            dataTable = NULL;
-
-            while (!stringPoolList.empty())
-            {
-                delete[] stringPoolList.front();
-                stringPoolList.pop_front();
-            }
-
-            nCount = 0;
-        }
-
-        iterator begin() { return iterator(indexTable.asT, nCount); }
-        iterator end() { return iterator(indexTable.asT, nCount, nCount); }
-
-    private:
-        char const* fmt;
-        uint32 nCount;
-        uint32 fieldCount;
-
-        union
-        {
-            T** asT;
-            char** asChar;
-        }
-        indexTable;
-
-        T* dataTable;
-        StringPoolList stringPoolList;
-
-        DBCStorage(DBCStorage const& right) = delete;
-        DBCStorage& operator=(DBCStorage const& right) = delete;
-};
-
-#endif
diff --git a/src/server/shared/DataStores/DBStorageIterator.h b/src/server/shared/DataStores/DBStorageIterator.h
index 3f9fa6eed24..5568397b245 100644
--- a/src/server/shared/DataStores/DBStorageIterator.h
+++ b/src/server/shared/DataStores/DBStorageIterator.h
@@ -35,9 +35,6 @@ public:
         }
     }
 
-    uint32 ID() const { return _pos; }
-    T const* Data() const { return _index[_pos]; }
-
     T const* operator->() { return _index[_pos]; }
     T const* operator*() { return _index[_pos]; }