feat(Core/Database): port TrinityCore database API (#5611)

src/server/database/Database/Field.cpp

@@ -1,57 +1,240 @@
 /*
- * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
  */
 
 #include "Field.h"
 #include "Errors.h"
+#include "Log.h"
+#include "MySQLHacks.h"
 
 Field::Field()
 {
     data.value = nullptr;
-    data.type = MYSQL_TYPE_NULL;
     data.length = 0;
     data.raw = false;
+    meta = nullptr;
 }
 
-Field::~Field()
-{
-    CleanUp();
-}
+Field::~Field() = default;
 
-void Field::SetByteValue(const void* newValue, const size_t newSize, enum_field_types newType, uint32 length)
+uint8 Field::GetUInt8() const
 {
-    if (data.value)
-        CleanUp();
+    if (!data.value)
+        return 0;
 
-    // This value stores raw bytes that have to be explicitly cast later
-    if (newValue)
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int8))
     {
-        data.value = new char[newSize];
-        memcpy(data.value, newValue, newSize);
-        data.length = length;
+        LogWrongType(__FUNCTION__);
+        return 0;
     }
-    data.type = newType;
-    data.raw = true;
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<uint8 const*>(data.value);
+    return static_cast<uint8>(strtoul(data.value, nullptr, 10));
 }
 
-void Field::SetStructuredValue(char* newValue, enum_field_types newType, uint32 length)
+int8 Field::GetInt8() const
 {
-    if (data.value)
-        CleanUp();
+    if (!data.value)
+        return 0;
 
-    // This value stores somewhat structured data that needs function style casting
-    if (newValue)
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int8))
     {
-        data.value = new char[length + 1];
-        memcpy(data.value, newValue, length);
-        *(reinterpret_cast<char*>(data.value) + length) = '\0';
-        data.length = length;
+        LogWrongType(__FUNCTION__);
+        return 0;
     }
+#endif
 
-    data.type = newType;
-    data.raw = false;
+    if (data.raw)
+        return *reinterpret_cast<int8 const*>(data.value);
+    return static_cast<int8>(strtol(data.value, nullptr, 10));
+}
+
+uint16 Field::GetUInt16() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int16))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<uint16 const*>(data.value);
+    return static_cast<uint16>(strtoul(data.value, nullptr, 10));
+}
+
+int16 Field::GetInt16() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int16))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<int16 const*>(data.value);
+    return static_cast<int16>(strtol(data.value, nullptr, 10));
+}
+
+uint32 Field::GetUInt32() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int32))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<uint32 const*>(data.value);
+    return static_cast<uint32>(strtoul(data.value, nullptr, 10));
+}
+
+int32 Field::GetInt32() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int32))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<int32 const*>(data.value);
+    return static_cast<int32>(strtol(data.value, nullptr, 10));
+}
+
+uint64 Field::GetUInt64() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int64))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<uint64 const*>(data.value);
+    return static_cast<uint64>(strtoull(data.value, nullptr, 10));
+}
+
+int64 Field::GetInt64() const
+{
+    if (!data.value)
+        return 0;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Int64))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<int64 const*>(data.value);
+    return static_cast<int64>(strtoll(data.value, nullptr, 10));
+}
+
+float Field::GetFloat() const
+{
+    if (!data.value)
+        return 0.0f;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Float))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0.0f;
+    }
+#endif
+
+    if (data.raw)
+        return *reinterpret_cast<float const*>(data.value);
+    return static_cast<float>(atof(data.value));
+}
+
+double Field::GetDouble() const
+{
+    if (!data.value)
+        return 0.0f;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (!IsType(DatabaseFieldTypes::Double) && !IsType(DatabaseFieldTypes::Decimal))
+    {
+        LogWrongType(__FUNCTION__);
+        return 0.0f;
+    }
+#endif
+
+    if (data.raw && !IsType(DatabaseFieldTypes::Decimal))
+        return *reinterpret_cast<double const*>(data.value);
+    return static_cast<double>(atof(data.value));
+}
+
+char const* Field::GetCString() const
+{
+    if (!data.value)
+        return nullptr;
+
+#ifdef ACORE_STRICT_DATABASE_TYPE_CHECKS
+    if (IsNumeric() && data.raw)
+    {
+        LogWrongType(__FUNCTION__);
+        return nullptr;
+    }
+#endif
+    return static_cast<char const*>(data.value);
+}
+
+std::string Field::GetString() const
+{
+    if (!data.value)
+        return "";
+
+    char const* string = GetCString();
+    if (!string)
+        return "";
+
+    return std::string(string, data.length);
+}
+
+std::string_view Field::GetStringView() const
+{
+    if (!data.value)
+        return {};
+
+    char const* const string = GetCString();
+    if (!string)
+        return {};
+
+    return { string, data.length };
 }
 
 std::vector<uint8> Field::GetBinary() const
@@ -67,6 +250,48 @@ std::vector<uint8> Field::GetBinary() const
 
 void Field::GetBinarySizeChecked(uint8* buf, size_t length) const
 {
-    ASSERT(data.value && (data.length == length));
+    ASSERT(data.value && (data.length == length), "Expected %zu-byte binary blob, got %sdata (%u bytes) instead", length, data.value ? "" : "no ", data.length);
     memcpy(buf, data.value, length);
 }
+
+void Field::SetByteValue(char const* newValue, uint32 length)
+{
+    // This value stores raw bytes that have to be explicitly cast later
+    data.value = newValue;
+    data.length = length;
+    data.raw = true;
+}
+
+void Field::SetStructuredValue(char const* newValue, uint32 length)
+{
+    // This value stores somewhat structured data that needs function style casting
+    data.value = newValue;
+    data.length = length;
+    data.raw = false;
+}
+
+bool Field::IsType(DatabaseFieldTypes type) const
+{
+    return meta->Type == type;
+}
+
+bool Field::IsNumeric() const
+{
+    return (meta->Type == DatabaseFieldTypes::Int8 ||
+        meta->Type == DatabaseFieldTypes::Int16 ||
+        meta->Type == DatabaseFieldTypes::Int32 ||
+        meta->Type == DatabaseFieldTypes::Int64 ||
+        meta->Type == DatabaseFieldTypes::Float ||
+        meta->Type == DatabaseFieldTypes::Double);
+}
+
+void Field::LogWrongType(char const* getter) const
+{
+    LOG_WARN("sql.sql", "Warning: %s on %s field %s.%s (%s.%s) at index %u.",
+        getter, meta->TypeName, meta->TableAlias, meta->Alias, meta->TableName, meta->Name, meta->Index);
+}
+
+void Field::SetMetadata(QueryResultFieldMetadata const* fieldMeta)
+{
+    meta = fieldMeta;
+}