Implement sql storage n and d format

Now we are able to define the index in the format and it can not be the first column.
This is needed for AreaTable. However we might need to double check why its done that way for that table.

Rremoved the need to define the name of the column as an index because code can find it using the provided format.

Added the support for table that have no index like gtcombatratings.

src/shared/Database/SQLStorage.h

@@ -104,6 +104,7 @@ class SQLStorage : public SQLStorageBase<ST>
 
     public:
         SQLStorage(const char* fmt, const char* _entry_field, const char* sqlname);
+        SQLStorage(const char* fmt, const char* sqlname);
 
         SQLStorage(const char* src_fmt, const char* dst_fmt, const char* _entry_field, const char* sqlname);
 

src/shared/Database/SQLStorageImpl.h

@@ -22,6 +22,7 @@
 #include "ProgressBar.h"
 #include "Log.h"
 #include "DBCFileLoader.h"
+#include <string>
 
 template<class DerivedLoader, class StorageClass>
 template<class S, class D>                                  // S source-type, D destination-type
@@ -129,6 +130,7 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::storeValue(V value, Stor
             offset += sizeof(char);
             break;
         case FT_INT:
+        case FT_IND:
             subclass->convert(x, value, *((uint32*)(&p[offset])));
             offset += sizeof(uint32);
             break;
@@ -156,7 +158,6 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::storeValue(V value, Stor
             subclass->default_fill(x, value, *((uint64*)(&p[offset])));
             offset += sizeof(uint64);
             break;
-        case FT_IND:
         case FT_SORT:
             assert(false && "SQL storage not have sort field types");
             break;
@@ -181,6 +182,7 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::storeValue(char const* v
             offset += sizeof(char);
             break;
         case FT_INT:
+        case FT_IND:
             subclass->convert_from_str(x, value, *((uint32*)(&p[offset])));
             offset += sizeof(uint32);
             break;
@@ -200,7 +202,6 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::storeValue(char const* v
             subclass->convert_from_str(x, value, *((uint64*)(&p[offset])));
             offset += sizeof(uint64);
             break;
-        case FT_IND:
         case FT_SORT:
             assert(false && "SQL storage not have sort field types");
             break;
@@ -213,30 +214,103 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::storeValue(char const* v
 template<class DerivedLoader, class StorageClass>
 void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store, bool error_at_empty /*= true*/)
 {
-    Field* fields = nullptr;
-    QueryResult* result  = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s", store.EntryFieldName(), store.GetTableName());
+    QueryResult* result = WorldDatabase.PQuery("SHOW COLUMNS FROM %s", store.GetTableName());
     if (!result)
     {
         sLog.outError("Error loading %s table (not exist?)\n", store.GetTableName());
         Log::WaitBeforeContinueIfNeed();
         exit(1);                                            // Stop server at loading non exited table or not accessable table
     }
 
-    uint32 maxRecordId = (*result)[0].GetUInt32() + 1;
+    std::vector<std::string> colNameList;
+    colNameList.reserve(result->GetRowCount());
+    do
+    {
+        Field* fields = result->Fetch();
+        colNameList.push_back(fields[0].GetString());
+    } while (result->NextRow());
+
+    delete result;
+
+    int32 indexPos = -1;
+    std::string indexName = store.EntryFieldName();
+    if (indexName.empty())
+    {
+        for (int32 i = 0; i < int32(store.GetDstFieldCount()); ++i)
+        {
+            auto format = store.GetSrcFormat(i);
+            if (format == FT_IND || format == FT_SORT)
+            {
+                indexPos = i;
+                break;
+            }
+        }
+
+        if (indexPos >= 0)
+        {
+            if (indexPos >= colNameList.size())
+            {
+                sLog.outError("Error loading %s table, provided index position is greater than column number\n", store.GetTableName());
+                Log::WaitBeforeContinueIfNeed();
+                exit(1);
+            }
+            indexName = colNameList[indexPos];
+        }
+    }
+    else
+    {
+        std::transform(indexName.begin(), indexName.end(), indexName.begin(), [](char c) { return std::tolower(c); });
+        for (uint32 i = 0; i < colNameList.size(); ++i)
+        {
+            std::string colName = colNameList[i];
+            std::transform(colName.begin(), colName.end(), colName.begin(), [](char c) { return std::tolower(c); });
+            if (indexName == colName)
+            {
+                indexName = colNameList[i];
+                indexPos = i;
+                break;
+            }
+        }
+
+        if (indexPos < 0)
+        {
+            sLog.outError("Error loading %s table (Entry field is not found in column name list)\n", store.GetTableName());
+            Log::WaitBeforeContinueIfNeed();
+            exit(1);
+        }
+    }
+
+    Field* fields = nullptr;
+    uint32 maxRecordId = 0;
     uint32 recordCount = 0;
     uint32 recordsize = 0;
-    delete result;
 
     result = WorldDatabase.PQuery("SELECT COUNT(*) FROM %s", store.GetTableName());
     if (result)
     {
-        fields = result->Fetch();
-        recordCount = fields[0].GetUInt32();
+        recordCount = result[0][0].GetUInt32();
         delete result;
     }
 
-    result = WorldDatabase.PQuery("SELECT * FROM %s", store.GetTableName());
+    if (indexPos < 0)
+    {
+        maxRecordId = recordCount;
+    }
+    else
+    {
+        result = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s", indexName.c_str(), store.GetTableName());
+        if (!result)
+        {
+            sLog.outError("Error loading %s table (not exist?)\n", store.GetTableName());
+            Log::WaitBeforeContinueIfNeed();
+            exit(1);                                            // Stop server at loading non exited table or not accessable table
+        }
+
+        maxRecordId = (*result)[0].GetUInt32() + 1;
+        delete result;
+    }
 
+    result = WorldDatabase.PQuery("SELECT * FROM %s", store.GetTableName());
     if (!result)
     {
         if (error_at_empty)
@@ -245,6 +319,7 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store
             sLog.outString("%s table is empty!\n", store.GetTableName());
 
         recordCount = 0;
+        maxRecordId = 0;
         return;
     }
 
@@ -268,6 +343,7 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store
             case FT_BYTE:
                 recordsize += sizeof(char);   break;
             case FT_INT:
+            case FT_IND:
                 recordsize += sizeof(uint32); break;
             case FT_FLOAT:
                 recordsize += sizeof(float);  break;
@@ -283,9 +359,7 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store
                 recordsize += sizeof(char*);  break;
             case FT_64BITINT:
                 recordsize += sizeof(uint64);  break;
-            case FT_IND:
             case FT_SORT:
-                assert(false && "SQL storage not have sort field types");
                 break;
             default:
                 assert(false && "unknown format character");
@@ -296,13 +370,20 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store
     // Prepare data storage and lookup storage
     store.prepareToLoad(maxRecordId, recordCount, recordsize);
 
+    uint32 generatedId = 0;
     BarGoLink bar(recordCount);
     do
     {
         fields = result->Fetch();
         bar.step();
 
-        char* record = store.createRecord(fields[0].GetUInt32());
+        uint32 id = 0;
+        if (indexPos < 0)
+            id = generatedId++;
+        else
+            id = fields[indexPos].GetUInt32();
+
+        char* record = store.createRecord(id);
         offset = 0;
 
         // dependend on dest-size
@@ -330,17 +411,20 @@ void SQLStorageLoaderBase<DerivedLoader, StorageClass>::Load(StorageClass& store
             {
                 case FT_LOGIC:  storeValue((bool)(fields[y].GetUInt32() > 0), store, record, x, offset);  ++x; break;
                 case FT_BYTE:   storeValue((char)fields[y].GetUInt8(), store, record, x, offset);         ++x; break;
+                case FT_IND:
                 case FT_INT:    storeValue((uint32)fields[y].GetUInt32(), store, record, x, offset);      ++x; break;
                 case FT_FLOAT:  storeValue((float)fields[y].GetFloat(), store, record, x, offset);        ++x; break;
                 case FT_STRING: storeValue((char const*)fields[y].GetString(), store, record, x, offset); ++x; break;
                 case FT_64BITINT: storeValue(fields[y].GetUInt64(), store, record, x, offset);            ++x; break;
+                case FT_SORT:
+                    ++x;
+                    break;
+
                 case FT_NA:
                 case FT_NA_BYTE:
                 case FT_NA_FLOAT:
                     // Do Not increase x
                     break;
-                case FT_IND:
-                case FT_SORT:
                 case FT_NA_POINTER:
                     assert(false && "SQL storage not have sort or pointer field types");
                     break;
@@ -378,6 +462,13 @@ void SQLStorage<ST>::Load(bool error_at_empty /*= true*/)
     loader.Load(*this, error_at_empty);
 }
 
+template<typename ST>
+SQLStorage<ST>::SQLStorage(const char* fmt, const char* sqlname)
+{
+    SQLStorage<ST>::Initialize(sqlname, "",fmt, fmt);
+    m_Index = nullptr;
+}
+
 template<typename ST>
 SQLStorage<ST>::SQLStorage(const char* fmt, const char* _entry_field, const char* sqlname)
 {
@@ -479,6 +570,7 @@ void SQLStorageBase<ST>::Free()
                 break;
             }
             case FT_NA:
+            case FT_IND:
             case FT_INT:
                 offset += sizeof(uint32);
                 break;
@@ -497,9 +589,7 @@ void SQLStorageBase<ST>::Free()
             case FT_64BITINT:
                 offset += sizeof(uint64);
                 break;
-            case FT_IND:
             case FT_SORT:
-                assert(false && "SQL storage not have sort field types");
                 break;
             default:
                 assert(false && "unknown format character");