refactor: Database abstraction and organization of files (#1274)

* Database: Convert to proper namespace

* Database: Use base class and getter

* Database: Move files around

* Database: Add property Management query

Database: Move over user queries

Tested at gm 0 that pre-approved names are pre-approved, unapproved need moderator approval
deleting characters deletes the selcted one
refreshing the character page shows the last character you logged in as
tested all my characters show up when i login
tested that you can delete all 4 characters and the correct character is selected each time
tested renaming, approving names as gm0

Database: Add ugc model getter

Hey it works, look I got around the mariadb issue.

Database: Add queries

Database: consolidate name query

Database: Add friends list query

Update name of approved names query

Documentation

Database: Add name check

Database: Add BFF Query

Database: Move BFF Setter

Database: Move new friend query

Database: Add remove friend queries

Database: Add activity log

Database: Add ugc & prop content removal

Database: Add model update

Database: Add migration queries

Database: Add character and xml queries

Database: Add user queries

Untested, but compiling code

Need to test that new character names are properly assigned in the following scenarios
gm 0 and pre-approved name
gm 0 and unapproved name
gm 9 and pre-approved name
gm 9 and unapproved name

Database: constify function arguments

Database: Add pet queries

* Database: Move property model queries

Untested.  Need to test
placing a new model
moving existing one
removing ugc model
placing ugc model
moving ugc model(?)
changing privacy option variously
change description and name
approve property
can properly travel to property

* Property: Move stale reference deletion

* Database: Move performance update query

* Database: Add bug report query

* Database: Add cheat detection query

* Database: Add mail send query

* Untested code

need to test mailing from slash command, from all users of SendMail, getting bbb of a property and sending messages to bffs

* Update CDComponentsRegistryTable.h

Database: Rename and add further comments

Datavbase: Add comments

Add some comments

Build: Fix PCH directories

Database: Fix time

thanks apple

Database: Fix compiler warnings

Overload destructor
Define specialty for time_t
Use string instead of string_view for temp empty string

Update CDTable.h

Property: Update queries to use mapId

Database: Reorganize

Reorganize into CDClient folder and GameDatabase folder for clearer meanings and file structure

Folders: Rename to GameDatabase

MySQL: Remove MySQL Specifier from table

Database: Move Tables to Interfaces

Database: Reorder functions in header

Database: Simplify property queries

Database: Remove unused queries

Remove extra query definitions as well

Database: Consolidate User getters

Database: Comment logs

Update MySQLDatabase.cpp

Database: Use generic code

Playkey: Fix bad optional access

Database: Move stuff around

WorldServer: Update queries

Ugc reduced by many scopes
use new queries
very fast
tested that ugc still loads

Database: Add auth queries

I tested that only the correct password can sign into an account.
Tested that disabled playkeys do not allow the user to play the game

Database: Add donation query

Database: add objectId queries

Database: Add master queries

Database: Fix mis-named function

Database: Add slash command queries

Mail: Fix itemId type

CharFilter: Use new query

ObjectID: Remove duplicate code

SlashCommand: Update query with function

Database: Add mail queries

Ugc: Fix issues with saving models

Resolve large scope blocks as well

* Database: Add debug try catch rethrow macro

* General fixes

* fix play key not working

* Further fixes

---------

Co-authored-by: Aaron Kimbre <aronwk.aaron@gmail.com>

dDatabase/GameDatabase/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(DDATABASE_GAMEDATABASE_SOURCES
+	"Database.cpp"
+	"MigrationRunner.cpp"
+)
+
+add_subdirectory(MySQL)
+
+foreach(file ${DDATABSE_DATABSES_MYSQL_SOURCES})
+	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "MySQL/${file}")
+endforeach()
+
+set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} PARENT_SCOPE)

dDatabase/GameDatabase/Database.cpp

@@ -0,0 +1,40 @@
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "Logger.h"
+#include "MySQLDatabase.h"
+#include "DluAssert.h"
+
+#pragma warning (disable:4251) //Disables SQL warnings
+
+namespace {
+	GameDatabase* database = nullptr;
+}
+
+void Database::Connect() {
+	if (database) {
+		LOG("Tried to connect to database when it's already connected!");
+		return;
+	}
+
+	database = new MySQLDatabase();
+	database->Connect();
+}
+
+GameDatabase* Database::Get() {
+	if (!database) {
+		LOG("Tried to get database when it's not connected!");
+		Connect();
+	}
+	return database;
+}
+
+void Database::Destroy(std::string source) {
+	if (database) {
+		database->Destroy(source);
+		delete database;
+		database = nullptr;
+	} else {
+		LOG("Trying to destroy database when it's not connected!");
+	}
+}

dDatabase/GameDatabase/Database.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <conncpp.hpp>
+
+#include "GameDatabase.h"
+
+namespace Database {
+	void Connect();
+	GameDatabase* Get();
+	void Destroy(std::string source = "");
+};

dDatabase/GameDatabase/GameDatabase.h

@@ -0,0 +1,55 @@
+#ifndef __GAMEDATABASE__H__
+#define __GAMEDATABASE__H__
+
+#include <optional>
+
+#include "ILeaderboard.h"
+#include "IPlayerCheatDetections.h"
+#include "ICommandLog.h"
+#include "IMail.h"
+#include "IObjectIdTracker.h"
+#include "IPlayKeys.h"
+#include "IServers.h"
+#include "IBugReports.h"
+#include "IPropertyContents.h"
+#include "IProperty.h"
+#include "IPetNames.h"
+#include "ICharXml.h"
+#include "IMigrationHistory.h"
+#include "IUgc.h"
+#include "IFriends.h"
+#include "ICharInfo.h"
+#include "IAccounts.h"
+#include "IActivityLog.h"
+
+namespace sql {
+	class Statement;
+	class PreparedStatement;
+};
+
+#ifdef _DEBUG
+#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (sql::SQLException& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
+#else
+#  define DLU_SQL_TRY_CATCH_RETHROW(x) x
+#endif // _DEBUG
+
+class GameDatabase :
+	public IPlayKeys, public ILeaderboard, public IObjectIdTracker, public IServers,
+	public IMail, public ICommandLog, public IPlayerCheatDetections, public IBugReports,
+	public IPropertyContents, public IProperty, public IPetNames, public ICharXml,
+	public IMigrationHistory, public IUgc, public IFriends, public ICharInfo,
+	public IAccounts, public IActivityLog {
+public:
+	virtual ~GameDatabase() = default;
+	// TODO: These should be made private.
+	virtual void Connect() = 0;
+	virtual void Destroy(std::string source = "") = 0;
+	virtual void ExecuteCustomQuery(const std::string_view query) = 0;
+	virtual sql::PreparedStatement* CreatePreppedStmt(const std::string& query) = 0;
+	virtual void Commit() = 0;
+	virtual bool GetAutoCommit() = 0;
+	virtual void SetAutoCommit(bool value) = 0;
+	virtual void DeleteCharacter(const uint32_t characterId) = 0;
+};
+
+#endif  //!__GAMEDATABASE__H__

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -0,0 +1,37 @@
+#ifndef __IACCOUNTS__H__
+#define __IACCOUNTS__H__
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+enum class eGameMasterLevel : uint8_t;
+
+class IAccounts {
+public:
+	struct Info {
+		std::string bcryptPassword;
+		uint32_t id{};
+		uint32_t playKeyId{};
+		bool banned{};
+		bool locked{};
+		eGameMasterLevel maxGmLevel{};
+	};
+
+	// Get the account info for the given username.
+	virtual std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) = 0;
+
+	// Update the account's unmute time.
+	virtual void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) = 0;
+
+	// Update the account's ban status.
+	virtual void UpdateAccountBan(const uint32_t accountId, const bool banned) = 0;
+
+	// Update the account's password.
+	virtual void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) = 0;
+
+	// Add a new account to the database.
+	virtual void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) = 0;
+};
+
+#endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -0,0 +1,19 @@
+#ifndef __IACTIVITYLOG__H__
+#define __IACTIVITYLOG__H__
+
+#include <cstdint>
+
+#include "dCommonVars.h"
+
+enum class eActivityType : uint32_t {
+	PlayerLoggedIn,
+	PlayerLoggedOut,
+};
+
+class IActivityLog {
+public:
+	// Update the activity log for the given account.
+	virtual void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
+};
+
+#endif  //!__IACTIVITYLOG__H__

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -0,0 +1,20 @@
+#ifndef __IBUGREPORTS__H__
+#define __IBUGREPORTS__H__
+
+#include <cstdint>
+#include <string_view>
+
+class IBugReports {
+public:
+	struct Info {
+		std::string body;
+		std::string clientVersion;
+		std::string otherPlayer;
+		std::string selection;
+		uint32_t characterId{};
+	};
+
+	// Add a new bug report to the database.
+	virtual void InsertNewBugReport(const Info& info) = 0;
+};
+#endif  //!__IBUGREPORTS__H__

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -0,0 +1,49 @@
+#ifndef __ICHARINFO__H__
+#define __ICHARINFO__H__
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "ePermissionMap.h"
+
+class ICharInfo {
+public:
+	struct Info {
+		std::string name;
+		std::string pendingName;
+		uint32_t id{};
+		uint32_t accountId{};
+		bool needsRename{};
+		LWOCLONEID cloneId{};
+		ePermissionMap permissionMap{};
+	};
+
+	// Get the approved names of all characters.
+	virtual std::vector<std::string> GetApprovedCharacterNames() = 0;
+
+	// Get the character info for the given character id.
+	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) = 0;
+
+	// Get the character info for the given character name.
+	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view name) = 0;
+	
+	// Get the character ids for the given account.
+	virtual std::vector<uint32_t> GetAccountCharacterIds(const uint32_t accountId) = 0;
+
+	// Insert a new character into the database.
+	virtual void InsertNewCharacter(const ICharInfo::Info info) = 0;
+
+	// Set the name of the given character.
+	virtual void SetCharacterName(const uint32_t characterId, const std::string_view name) = 0;
+
+	// Set the pending name of the given character.
+	virtual void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) = 0;
+
+	// Updates the given character ids last login to be right now.
+	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
+};
+
+#endif  //!__ICHARINFO__H__

dDatabase/GameDatabase/ITables/ICharXml.h

@@ -0,0 +1,20 @@
+#ifndef __ICHARXML__H__
+#define __ICHARXML__H__
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+class ICharXml {
+public:
+	// Get the character xml for the given character id.
+	virtual std::string GetCharacterXml(const uint32_t charId) = 0;
+
+	// Update the character xml for the given character id.
+	virtual void UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) = 0;
+
+	// Insert the character xml for the given character id.
+	virtual void InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) = 0;
+};
+
+#endif  //!__ICHARXML__H__

dDatabase/GameDatabase/ITables/ICommandLog.h

@@ -0,0 +1,14 @@
+#ifndef __ICOMMANDLOG__H__
+#define __ICOMMANDLOG__H__
+
+#include <cstdint>
+#include <string_view>
+
+class ICommandLog {
+public:	
+
+	// Insert a new slash command log entry.
+	virtual void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) = 0;
+};
+
+#endif  //!__ICOMMANDLOG__H__

dDatabase/GameDatabase/ITables/IFriends.h

@@ -0,0 +1,32 @@
+#ifndef __IFRIENDS__H__
+#define __IFRIENDS__H__
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+class IFriends {
+public:
+	struct BestFriendStatus {
+		uint32_t playerCharacterId{};
+		uint32_t friendCharacterId{};
+		uint32_t bestFriendStatus{};
+	};
+
+	// Get the friends list for the given character id.
+	virtual std::vector<FriendData> GetFriendsList(const uint32_t charId) = 0;
+
+	// Get the best friend status for the given player and friend character ids.
+	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+
+	// Set the best friend status for the given player and friend character ids.
+	virtual void SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) = 0;
+
+	// Add a friend to the given character id.
+	virtual void AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+
+	// Remove a friend from the given character id.
+	virtual void RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+};
+
+#endif  //!__IFRIENDS__H__

dDatabase/GameDatabase/ITables/ILeaderboard.h

@@ -0,0 +1,14 @@
+#ifndef __ILEADERBOARD__H__
+#define __ILEADERBOARD__H__
+
+#include <cstdint>
+#include <optional>
+
+class ILeaderboard {
+public:
+
+	// Get the donation total for the given activity id.
+	virtual std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) = 0;
+};
+
+#endif  //!__ILEADERBOARD__H__

dDatabase/GameDatabase/ITables/IMail.h

@@ -0,0 +1,54 @@
+#ifndef __IMAIL__H__
+#define __IMAIL__H__
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+#include "dCommonVars.h"
+#include "NiQuaternion.h"
+#include "NiPoint3.h"
+
+class IMail {
+public:
+	struct MailInfo {
+		std::string senderUsername;
+		std::string recipient;
+		std::string subject;
+		std::string body;
+		uint64_t id{};
+		uint32_t senderId{};
+		uint32_t receiverId{};
+		uint64_t timeSent{};
+		bool wasRead{};
+		struct {
+			LWOOBJID itemID{};
+			int32_t itemCount{};
+			LOT itemLOT{};
+			LWOOBJID itemSubkey{};
+		};
+	};
+
+	// Insert a new mail into the database.
+	virtual void InsertNewMail(const MailInfo& mail) = 0;
+
+	// Get the mail for the given character id.
+	virtual std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) = 0;
+
+	// Get the mail for the given mail id.
+	virtual std::optional<MailInfo> GetMail(const uint64_t mailId) = 0;
+
+	// Get the number of unread mail for the given character id.
+	virtual uint32_t GetUnreadMailCount(const uint32_t characterId) = 0;
+
+	// Mark the given mail as read.
+	virtual void MarkMailRead(const uint64_t mailId) = 0;
+
+	// Claim the item from the given mail.
+	virtual void ClaimMailItem(const uint64_t mailId) = 0;
+
+	// Delete the given mail.
+	virtual void DeleteMail(const uint64_t mailId) = 0;
+};
+
+#endif  //!__IMAIL__H__

dDatabase/GameDatabase/ITables/IMigrationHistory.h

@@ -0,0 +1,17 @@
+#ifndef __IMIGRATIONHISTORY__H__
+#define __IMIGRATIONHISTORY__H__
+
+#include <string_view>
+
+class IMigrationHistory {
+public:
+	// Create the migration history table.
+	virtual void CreateMigrationHistoryTable() = 0;
+
+	// Check if the given migration has been run.
+	virtual bool IsMigrationRun(const std::string_view str) = 0;
+
+	// Insert the given migration into the migration history table.
+	virtual void InsertMigration(const std::string_view str) = 0;
+};
+#endif  //!__IMIGRATIONHISTORY__H__

dDatabase/GameDatabase/ITables/IObjectIdTracker.h

@@ -0,0 +1,19 @@
+#ifndef __IOBJECTIDTRACKER__H__
+#define __IOBJECTIDTRACKER__H__
+
+#include <cstdint>
+#include <optional>
+
+class IObjectIdTracker {
+public:
+	// Get the current persistent id.
+	virtual std::optional<uint32_t> GetCurrentPersistentId() = 0;
+
+	// Insert the default persistent id.
+	virtual void InsertDefaultPersistentId() = 0;
+
+	// Update the persistent id.
+	virtual void UpdatePersistentId(const uint32_t newId) = 0;
+};
+
+#endif  //!__IOBJECTIDTRACKER__H__

dDatabase/GameDatabase/ITables/IPetNames.h

@@ -0,0 +1,21 @@
+#ifndef __IPETNAMES__H__
+#define __IPETNAMES__H__
+
+#include <cstdint>
+#include <optional>
+
+class IPetNames {
+public:
+	struct Info {
+		std::string petName;
+		int32_t approvalStatus{};
+	};
+
+	// Set the pet name moderation status for the given pet id.
+	virtual void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) = 0;
+
+	// Get pet info for the given pet id.
+	virtual std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) = 0;
+};
+
+#endif  //!__IPETNAMES__H__

dDatabase/GameDatabase/ITables/IPlayKeys.h

@@ -0,0 +1,15 @@
+#ifndef __IPLAYKEYS__H__
+#define __IPLAYKEYS__H__
+
+#include <cstdint>
+#include <optional>
+
+class IPlayKeys {
+public:
+	// Get the playkey id for the given playkey.
+	// Optional of bool may seem pointless, however the optional indicates if the playkey exists
+	// and the bool indicates if the playkey is active.
+	virtual std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) = 0;
+};
+
+#endif  //!__IPLAYKEYS__H__

dDatabase/GameDatabase/ITables/IPlayerCheatDetections.h

@@ -0,0 +1,20 @@
+#ifndef __IPLAYERCHEATDETECTIONS__H__
+#define __IPLAYERCHEATDETECTIONS__H__
+
+#include <cstdint>
+#include <optional>
+
+class IPlayerCheatDetections {
+public:
+	struct Info {
+		std::optional<uint32_t> userId = std::nullopt;
+		std::string username;
+		std::string systemAddress;
+		std::string extraMessage;
+	};
+
+	// Insert a new cheat detection.
+	virtual void InsertCheatDetection(const IPlayerCheatDetections::Info& info) = 0;
+};
+
+#endif  //!__IPLAYERCHEATDETECTIONS__H__

dDatabase/GameDatabase/ITables/IProperty.h

@@ -0,0 +1,38 @@
+#ifndef __IPROPERTY__H__
+#define __IPROPERTY__H__
+
+#include <cstdint>
+#include <optional>
+
+class IProperty {
+public:
+	struct Info {
+		std::string name;
+		std::string description;
+		std::string rejectionReason;
+		LWOOBJID id{};
+		uint32_t ownerId{};
+		LWOCLONEID cloneId{};
+		int32_t privacyOption{};
+		uint32_t modApproved{};
+		uint32_t lastUpdatedTime{};
+		uint32_t claimedTime{};
+		uint32_t reputation{};
+	};
+
+	// Get the property info for the given property id.
+	virtual std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) = 0;
+
+	// Update the property moderation info for the given property id.
+	virtual void UpdatePropertyModerationInfo(const IProperty::Info& info) = 0;
+	
+	// Update the property details for the given property id.
+	virtual void UpdatePropertyDetails(const IProperty::Info& info) = 0;
+
+	// Update the property performance cost for the given property id.
+	virtual void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) = 0;
+	
+	// Insert a new property into the database.
+	virtual void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) = 0;
+};
+#endif  //!__IPROPERTY__H__

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -0,0 +1,40 @@
+#ifndef __IPROPERTIESCONTENTS__H__
+#define __IPROPERTIESCONTENTS__H__
+
+#include <cstdint>
+#include <string_view>
+
+class IPropertyContents {
+public:	
+	struct Model {
+		inline bool operator==(const LWOOBJID& other) const noexcept {
+			return id == other;
+		}
+
+		NiPoint3 position;
+		NiQuaternion rotation;
+		LWOOBJID id{};
+		LOT lot{};
+		uint32_t ugcId{};
+	};
+
+	// Inserts a new UGC model into the database.
+	virtual void InsertNewUgcModel(
+		std::istringstream& sd0Data,
+		const uint32_t blueprintId,
+		const uint32_t accountId,
+		const uint32_t characterId) = 0;
+
+	// Get the property models for the given property id.
+	virtual std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) = 0;
+
+	// Insert a new property model into the database.
+	virtual void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) = 0;
+
+	// Update the model position and rotation for the given property id.
+	virtual void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) = 0;
+
+	// Remove the model for the given property id.
+	virtual void RemoveModel(const LWOOBJID& modelId) = 0;
+};
+#endif  //!__IPROPERTIESCONTENTS__H__

dDatabase/GameDatabase/ITables/IServers.h

@@ -0,0 +1,21 @@
+#ifndef __ISERVERS__H__
+#define __ISERVERS__H__
+
+#include <cstdint>
+#include <optional>
+
+class IServers {
+public:
+	struct MasterInfo {
+		std::string ip;
+		uint32_t port{};
+	};
+
+	// Set the master server ip and port.
+	virtual void SetMasterIp(const std::string_view ip, const uint32_t port) = 0;
+
+	// Get the master server info.
+	virtual std::optional<MasterInfo> GetMasterInfo() = 0;
+};
+
+#endif  //!__ISERVERS__H__

dDatabase/GameDatabase/ITables/IUgc.h

@@ -0,0 +1,32 @@
+#ifndef __IUGC__H__
+#define __IUGC__H__
+
+#include <cstdint>
+#include <sstream>
+#include <optional>
+#include <string>
+#include <string_view>
+
+class IUgc {
+public:
+	struct Model {
+		std::stringstream lxfmlData;
+		LWOOBJID id{};
+	};
+
+	// Gets all UGC models for the given property id.
+	virtual std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) = 0;
+
+	// Gets all Ugcs models.
+	virtual std::vector<IUgc::Model> GetAllUgcModels() = 0;
+	
+	// Removes ugc models that are not referenced by any property.
+	virtual void RemoveUnreferencedUgcModels() = 0;
+
+	// Deletes the ugc model for the given model id.
+	virtual void DeleteUgcModelData(const LWOOBJID& modelId) = 0;
+
+	// Inserts a new UGC model into the database.
+	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) = 0;
+};
+#endif  //!__IUGC__H__

dDatabase/GameDatabase/MigrationRunner.cpp

@@ -0,0 +1,133 @@
+#include "MigrationRunner.h"
+
+#include "BrickByBrickFix.h"
+#include "CDClientDatabase.h"
+#include "Database.h"
+#include "Game.h"
+#include "GeneralUtils.h"
+#include "Logger.h"
+#include "BinaryPathFinder.h"
+
+#include <fstream>
+
+Migration LoadMigration(std::string path) {
+	Migration migration{};
+	std::ifstream file(BinaryPathFinder::GetBinaryDir() / "migrations/" / path);
+
+	if (file.is_open()) {
+		std::string line;
+		std::string total = "";
+
+		while (std::getline(file, line)) {
+			total += line;
+		}
+
+		file.close();
+
+		migration.name = path;
+		migration.data = total;
+	}
+
+	return migration;
+}
+
+void MigrationRunner::RunMigrations() {
+	Database::Get()->CreateMigrationHistoryTable();
+
+	sql::SQLString finalSQL = "";
+	bool runSd0Migrations = false;
+	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/").string())) {
+		auto migration = LoadMigration("dlu/" + entry);
+
+		if (migration.data.empty()) {
+			continue;
+		}
+
+		if (Database::Get()->IsMigrationRun(migration.name)) continue;
+
+		LOG("Running migration: %s", migration.name.c_str());
+		if (migration.name == "dlu/5_brick_model_sd0.sql") {
+			runSd0Migrations = true;
+		} else {
+			finalSQL.append(migration.data.c_str());
+		}
+
+		Database::Get()->InsertMigration(migration.name);
+	}
+
+	if (finalSQL.empty() && !runSd0Migrations) {
+		LOG("Server database is up to date.");
+		return;
+	}
+
+	if (!finalSQL.empty()) {
+		auto migration = GeneralUtils::SplitString(static_cast<std::string>(finalSQL), ';');
+		for (auto& query : migration) {
+			try {
+				if (query.empty()) continue;
+				Database::Get()->ExecuteCustomQuery(query.c_str());
+			} catch (sql::SQLException& e) {
+				LOG("Encountered error running migration: %s", e.what());
+			}
+		}
+	}
+
+	// Do this last on the off chance none of the other migrations have been run yet.
+	if (runSd0Migrations) {
+		uint32_t numberOfUpdatedModels = BrickByBrickFix::UpdateBrickByBrickModelsToSd0();
+		LOG("%i models were updated from zlib to sd0.", numberOfUpdatedModels);
+		uint32_t numberOfTruncatedModels = BrickByBrickFix::TruncateBrokenBrickByBrickXml();
+		LOG("%i models were truncated from the database.", numberOfTruncatedModels);
+	}
+}
+
+void MigrationRunner::RunSQLiteMigrations() {
+	auto cdstmt = CDClientDatabase::CreatePreppedStmt("CREATE TABLE IF NOT EXISTS migration_history (name TEXT NOT NULL, date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP);");
+	cdstmt.execQuery().finalize();
+	cdstmt.finalize();
+
+	Database::Get()->CreateMigrationHistoryTable();
+
+	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "migrations/cdserver/").string())) {
+		auto migration = LoadMigration("cdserver/" + entry);
+
+		if (migration.data.empty()) continue;
+
+		// Check if there is an entry in the migration history table on the cdclient database.
+		cdstmt = CDClientDatabase::CreatePreppedStmt("SELECT name FROM migration_history WHERE name = ?;");
+		cdstmt.bind((int32_t) 1, migration.name.c_str());
+		auto cdres = cdstmt.execQuery();
+
+		if (!cdres.eof()) continue;
+
+		// Check first if there is entry in the migration history table on the main database.
+		if (Database::Get()->IsMigrationRun(migration.name)) {
+			// Insert into cdclient database if there is an entry in the main database but not the cdclient database.
+			cdstmt = CDClientDatabase::CreatePreppedStmt("INSERT INTO migration_history (name) VALUES (?);");
+			cdstmt.bind(static_cast<int32_t>(1), migration.name.c_str());
+			cdstmt.execQuery();
+			continue;
+		}
+
+		// Doing these 1 migration at a time since one takes a long time and some may think it is crashing.
+		// This will at the least guarentee that the full migration needs to be run in order to be counted as "migrated".
+		LOG("Executing migration: %s.  This may take a while.  Do not shut down server.", migration.name.c_str());
+		CDClientDatabase::ExecuteQuery("BEGIN TRANSACTION;");
+		for (const auto& dml : GeneralUtils::SplitString(migration.data, ';')) {
+			if (dml.empty()) continue;
+			try {
+				CDClientDatabase::ExecuteDML(dml.c_str());
+			} catch (CppSQLite3Exception& e) {
+				LOG("Encountered error running DML command: (%i) : %s", e.errorCode(), e.errorMessage());
+			}
+		}
+
+		// Insert into cdclient database.
+		cdstmt = CDClientDatabase::CreatePreppedStmt("INSERT INTO migration_history (name) VALUES (?);");
+		cdstmt.bind((int32_t) 1, migration.name.c_str());
+		cdstmt.execQuery();
+		CDClientDatabase::ExecuteQuery("COMMIT;");
+	}
+
+	LOG("CDServer database is up to date.");
+}

dDatabase/GameDatabase/MigrationRunner.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+struct Migration {
+	std::string data;
+	std::string name;
+};
+
+namespace MigrationRunner {
+	void RunMigrations();
+	void RunSQLiteMigrations();
+};

dDatabase/GameDatabase/MySQL/CMakeLists.txt

@@ -0,0 +1,11 @@
+SET(DDATABSE_DATABSES_MYSQL_SOURCES
+	"MySQLDatabase.cpp"
+)
+
+add_subdirectory(Tables)
+
+foreach(file ${DDATABASES_DATABASES_MYSQL_TABLES_SOURCES})
+	set(DDATABSE_DATABSES_MYSQL_SOURCES ${DDATABSE_DATABSES_MYSQL_SOURCES} "Tables/${file}")
+endforeach()
+
+set(DDATABSE_DATABSES_MYSQL_SOURCES ${DDATABSE_DATABSES_MYSQL_SOURCES} PARENT_SCOPE)

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -0,0 +1,113 @@
+#include "MySQLDatabase.h"
+
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "Logger.h"
+
+namespace {
+	std::string databaseName;
+	sql::Properties properties;
+	sql::Driver* driver = nullptr;
+	sql::Connection* con = nullptr;
+};
+
+void MySQLDatabase::Connect() {
+	driver = sql::mariadb::get_driver_instance();
+
+	// The mariadb connector is *supposed* to handle unix:// and pipe:// prefixes to hostName, but there are bugs where
+	// 1) it tries to parse a database from the connection string (like in tcp://localhost:3001/darkflame) based on the
+	//    presence of a /
+	// 2) even avoiding that, the connector still assumes you're connecting with a tcp socket
+	// So, what we do in the presence of a unix socket or pipe is to set the hostname to the protocol and localhost,
+	// which avoids parsing errors while still ensuring the correct connection type is used, and then setting the appropriate
+	// property manually (which the URL parsing fails to do)
+	const std::string UNIX_PROTO = "unix://";
+	const std::string PIPE_PROTO = "pipe://";
+	std::string mysql_host = Game::config->GetValue("mysql_host");
+	if (mysql_host.find(UNIX_PROTO) == 0) {
+		properties["hostName"] = "unix://localhost";
+		properties["localSocket"] = mysql_host.substr(UNIX_PROTO.length()).c_str();
+	} else if (mysql_host.find(PIPE_PROTO) == 0) {
+		properties["hostName"] = "pipe://localhost";
+		properties["pipe"] = mysql_host.substr(PIPE_PROTO.length()).c_str();
+	} else {
+		properties["hostName"] = mysql_host.c_str();
+	}
+	properties["user"] = Game::config->GetValue("mysql_username").c_str();
+	properties["password"] = Game::config->GetValue("mysql_password").c_str();
+	properties["autoReconnect"] = "true";
+
+	databaseName = Game::config->GetValue("mysql_database").c_str();
+
+	// `connect(const Properties& props)` segfaults in windows debug, but
+	// `connect(const SQLString& host, const SQLString& user, const SQLString& pwd)` doesn't handle pipes/unix sockets correctly
+	if (properties.find("localSocket") != properties.end() || properties.find("pipe") != properties.end()) {
+		con = driver->connect(properties);
+	} else {
+		con = driver->connect(properties["hostName"].c_str(), properties["user"].c_str(), properties["password"].c_str());
+	}
+	con->setSchema(databaseName.c_str());
+}
+
+void MySQLDatabase::Destroy(std::string source) {
+	if (!con) return;
+
+	if (source.empty()) LOG("Destroying MySQL connection!");
+	else LOG("Destroying MySQL connection from %s!", source.c_str());
+
+	con->close();
+	delete con;
+	con = nullptr;
+}
+
+void MySQLDatabase::ExecuteCustomQuery(const std::string_view query) {
+	std::unique_ptr<sql::Statement>(con->createStatement())->execute(query.data());
+}
+
+sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& query) {
+	if (!con) {
+		Connect();
+		LOG("Trying to reconnect to MySQL");
+	}
+
+	if (!con->isValid() || con->isClosed()) {
+		delete con;
+
+		con = nullptr;
+
+		Connect();
+		LOG("Trying to reconnect to MySQL from invalid or closed connection");
+	}
+
+	return con->prepareStatement(sql::SQLString(query.c_str(), query.length()));
+}
+
+void MySQLDatabase::Commit() {
+	con->commit();
+}
+
+bool MySQLDatabase::GetAutoCommit() {
+	// TODO This should not just access a pointer.  A future PR should update this
+	// to check for null and throw an error if the connection is not valid.
+	return con->getAutoCommit();
+}
+
+void MySQLDatabase::SetAutoCommit(bool value) {
+	// TODO This should not just access a pointer.  A future PR should update this
+	// to check for null and throw an error if the connection is not valid.
+	con->setAutoCommit(value);
+}
+
+void MySQLDatabase::DeleteCharacter(const uint32_t characterId) {
+	ExecuteDelete("DELETE FROM charxml WHERE id=? LIMIT 1;", characterId);
+	ExecuteDelete("DELETE FROM command_log WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM friends WHERE player_id=? OR friend_id=?;", characterId, characterId);
+	ExecuteDelete("DELETE FROM leaderboard WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM properties_contents WHERE property_id IN (SELECT id FROM properties WHERE owner_id=?);", characterId);
+	ExecuteDelete("DELETE FROM properties WHERE owner_id=?;", characterId);
+	ExecuteDelete("DELETE FROM ugc WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM activity_log WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM mail WHERE receiver_id=?;", characterId);
+	ExecuteDelete("DELETE FROM charinfo WHERE id=? LIMIT 1;", characterId);
+}

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -0,0 +1,245 @@
+#ifndef __MYSQLDATABASE__H__
+#define __MYSQLDATABASE__H__
+
+#include <conncpp.hpp>
+#include <memory>
+
+#include "GameDatabase.h"
+
+typedef std::unique_ptr<sql::PreparedStatement>& UniquePreppedStmtRef;
+
+// Purposefully no definition for this to provide linker errors in the case someone tries to
+// bind a parameter to a type that isn't defined.
+template<typename ParamType>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const ParamType param);
+
+// This is a function to set each parameter in a prepared statement.
+// This is accomplished with a combination of parameter packing and Fold Expressions.
+// The constexpr if statement is used to prevent the compiler from trying to call SetParam with 0 arguments.
+template<typename... Args>
+void SetParams(UniquePreppedStmtRef stmt, Args&&... args) {
+	if constexpr (sizeof...(args) != 0) {
+		int i = 1;
+		(SetParam(stmt, i++, args), ...);
+	}
+}
+
+class MySQLDatabase : public GameDatabase {
+public:
+	void Connect() override;
+	void Destroy(std::string source = "") override;
+
+	sql::PreparedStatement* CreatePreppedStmt(const std::string& query) override;
+	void Commit() override;
+	bool GetAutoCommit() override;
+	void SetAutoCommit(bool value) override;
+	void ExecuteCustomQuery(const std::string_view query) override;
+
+	// Overloaded queries
+	std::optional<IServers::MasterInfo> GetMasterInfo() override;
+
+	std::vector<std::string> GetApprovedCharacterNames() override;
+
+	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
+
+	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
+	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
+	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
+	void DeleteUgcModelData(const LWOOBJID& modelId) override;
+	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
+	std::vector<IUgc::Model> GetAllUgcModels() override;
+	void CreateMigrationHistoryTable() override;
+	bool IsMigrationRun(const std::string_view str) override;
+	void InsertMigration(const std::string_view str) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
+	std::string GetCharacterXml(const uint32_t accountId) override;
+	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
+	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
+	void InsertNewCharacter(const ICharInfo::Info info) override;
+	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
+	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
+	void DeleteCharacter(const uint32_t characterId) override;
+	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
+	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
+	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
+	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
+	void UpdatePropertyModerationInfo(const IProperty::Info& info) override;
+	void UpdatePropertyDetails(const IProperty::Info& info) override;
+	void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) override;
+	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
+	void RemoveUnreferencedUgcModels() override;
+	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
+	void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) override;
+	void RemoveModel(const LWOOBJID& modelId) override;
+	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
+	void InsertNewBugReport(const IBugReports::Info& info) override;
+	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
+	void InsertNewMail(const IMail::MailInfo& mail) override;
+	void InsertNewUgcModel(
+		std::istringstream& sd0Data,
+		const uint32_t blueprintId,
+		const uint32_t accountId,
+		const uint32_t characterId) override;
+	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
+	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
+	void MarkMailRead(const uint64_t mailId) override;
+	void DeleteMail(const uint64_t mailId) override;
+	void ClaimMailItem(const uint64_t mailId) override;
+	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
+	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
+	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
+	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
+	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
+	void SetMasterIp(const std::string_view ip, const uint32_t port) override;
+	std::optional<uint32_t> GetCurrentPersistentId() override;
+	void InsertDefaultPersistentId() override;
+	void UpdatePersistentId(const uint32_t id) override;
+	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
+	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
+	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
+private:
+
+	// Generic query functions that can be used for any query.
+	// Return type may be different depending on the query, so it is up to the caller to check the return type.
+	// The first argument is the query string, and the rest are the parameters to bind to the query.
+	// The return type is a unique_ptr to the result set, which is deleted automatically when it goes out of scope
+	template<typename... Args>
+	inline std::unique_ptr<sql::ResultSet> ExecuteSelect(const std::string& query, Args&&... args) {
+		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return std::unique_ptr<sql::ResultSet>(preppedStmt->executeQuery()));
+	}
+
+	template<typename... Args>
+	inline void ExecuteDelete(const std::string& query, Args&&... args) {
+		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(preppedStmt->execute());
+	}
+
+	template<typename... Args>
+	inline int32_t ExecuteUpdate(const std::string& query, Args&&... args) {
+		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt->executeUpdate());
+	}
+
+	template<typename... Args>
+	inline bool ExecuteInsert(const std::string& query, Args&&... args) {
+		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt->execute());
+	}
+};
+
+// Below are each of the definitions of SetParam for each supported type.
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string_view param) {
+	// LOG("%s", param.data());
+	stmt->setString(index, param.data());
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const char* param) {
+	// LOG("%s", param);
+	stmt->setString(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string param) {
+	// LOG("%s", param.c_str());
+	stmt->setString(index, param.c_str());
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int8_t param) {
+	// LOG("%u", param);
+	stmt->setByte(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint8_t param) {
+	// LOG("%d", param);
+	stmt->setByte(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int16_t param) {
+	// LOG("%u", param);
+	stmt->setShort(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint16_t param) {
+	// LOG("%d", param);
+	stmt->setShort(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint32_t param) {
+	// LOG("%u", param);
+	stmt->setUInt(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int32_t param) {
+	// LOG("%d", param);
+	stmt->setInt(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int64_t param) {
+	// LOG("%llu", param);
+	stmt->setInt64(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint64_t param) {
+	// LOG("%llu", param);
+	stmt->setUInt64(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const float param) {
+	// LOG("%f", param);
+	stmt->setFloat(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const double param) {
+	// LOG("%f", param);
+	stmt->setDouble(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const bool param) {
+	// LOG("%d", param);
+	stmt->setBoolean(index, param);
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::istream* param) {
+	// LOG("Blob");
+	// This is the one time you will ever see me use const_cast.
+	stmt->setBlob(index, const_cast<std::istream*>(param));
+}
+
+template<>
+inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
+	if (param) {
+		// LOG("%d", param.value());
+		stmt->setInt(index, param.value());
+	} else {
+		// LOG("Null");
+		stmt->setNull(index, sql::DataType::SQLNULL);
+	}
+}
+
+#endif  //!__MYSQLDATABASE__H__

dDatabase/GameDatabase/MySQL/Tables/Accounts.cpp

@@ -0,0 +1,37 @@
+#include "MySQLDatabase.h"
+
+#include "eGameMasterLevel.h"
+
+std::optional<IAccounts::Info> MySQLDatabase::GetAccountInfo(const std::string_view username) {
+	auto result = ExecuteSelect("SELECT id, password, banned, locked, play_key_id, gm_level FROM accounts WHERE name = ? LIMIT 1;", username);
+
+	if (!result->next()) {
+		return std::nullopt;
+	}
+
+	IAccounts::Info toReturn;
+	toReturn.id = result->getUInt("id");
+	toReturn.maxGmLevel = static_cast<eGameMasterLevel>(result->getInt("gm_level"));
+	toReturn.bcryptPassword = result->getString("password").c_str();
+	toReturn.banned = result->getBoolean("banned");
+	toReturn.locked = result->getBoolean("locked");
+	toReturn.playKeyId = result->getUInt("play_key_id");
+
+	return toReturn;
+}
+
+void MySQLDatabase::UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) {
+	ExecuteUpdate("UPDATE accounts SET mute_expire = ? WHERE id = ?;", timeToUnmute, accountId);
+}
+
+void MySQLDatabase::UpdateAccountBan(const uint32_t accountId, const bool banned) {
+	ExecuteUpdate("UPDATE accounts SET banned = ? WHERE id = ?;", banned, accountId);
+}
+
+void MySQLDatabase::UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) {
+	ExecuteUpdate("UPDATE accounts SET password = ? WHERE id = ?;", bcryptpassword, accountId);
+}
+
+void MySQLDatabase::InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) {
+	ExecuteInsert("INSERT INTO accounts (name, password, gm_level) VALUES (?, ?, ?);", username, bcryptpassword, static_cast<int32_t>(eGameMasterLevel::OPERATOR));
+}

dDatabase/GameDatabase/MySQL/Tables/ActivityLog.cpp

@@ -0,0 +1,6 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
+	ExecuteInsert("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);",
+		characterId, static_cast<uint32_t>(activityType), static_cast<uint32_t>(time(NULL)), mapId);
+}

dDatabase/GameDatabase/MySQL/Tables/BugReports.cpp

@@ -0,0 +1,6 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::InsertNewBugReport(const IBugReports::Info& info) {
+	ExecuteInsert("INSERT INTO `bug_reports`(body, client_version, other_player_id, selection, reporter_id) VALUES (?, ?, ?, ?, ?)",
+		info.body, info.clientVersion, info.otherPlayer, info.selection, info.characterId);
+}

dDatabase/GameDatabase/MySQL/Tables/CMakeLists.txt

@@ -0,0 +1,22 @@
+set(DDATABASES_DATABASES_MYSQL_TABLES_SOURCES
+	"Accounts.cpp"
+	"ActivityLog.cpp"
+	"BugReports.cpp"
+	"CharInfo.cpp"
+	"CharXml.cpp"
+	"CommandLog.cpp"
+	"Friends.cpp"
+	"Leaderboard.cpp"
+	"Mail.cpp"
+	"MigrationHistory.cpp"
+	"ObjectIdTracker.cpp"
+	"PetNames.cpp"
+	"PlayerCheatDetections.cpp"
+	"PlayKeys.cpp"
+	"Property.cpp"
+	"PropertyContents.cpp"
+	"Servers.cpp"
+	"Ugc.cpp"
+	PARENT_SCOPE
+)
+

dDatabase/GameDatabase/MySQL/Tables/CharInfo.cpp

@@ -0,0 +1,78 @@
+#include "MySQLDatabase.h"
+
+std::vector<std::string> MySQLDatabase::GetApprovedCharacterNames() {
+	auto result = ExecuteSelect("SELECT name FROM charinfo;");
+
+	std::vector<std::string> toReturn;
+
+	while (result->next()) {
+		toReturn.push_back(result->getString("name").c_str());
+	}
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> CharInfoFromQueryResult(std::unique_ptr<sql::ResultSet> stmt) {
+	if (!stmt->next()) {
+		return std::nullopt;
+	}
+
+	ICharInfo::Info toReturn;
+
+	toReturn.id = stmt->getUInt("id");
+	toReturn.name = stmt->getString("name").c_str();
+	toReturn.pendingName = stmt->getString("pending_name").c_str();
+	toReturn.needsRename = stmt->getBoolean("needs_rename");
+	toReturn.cloneId = stmt->getUInt64("prop_clone_id");
+	toReturn.accountId = stmt->getUInt("account_id");
+	toReturn.permissionMap = static_cast<ePermissionMap>(stmt->getUInt("permission_map"));
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const uint32_t charId) {
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId)
+	);
+}
+
+std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const std::string_view name) {
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE name = ? LIMIT 1;", name)
+	);
+}
+
+std::vector<uint32_t> MySQLDatabase::GetAccountCharacterIds(const uint32_t accountId) {
+	auto result = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
+
+	std::vector<uint32_t> toReturn;
+	toReturn.reserve(result->rowsCount());
+	while (result->next()) {
+		toReturn.push_back(result->getUInt("id"));
+	}
+
+	return toReturn;
+}
+
+void MySQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
+	ExecuteInsert(
+		"INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`) VALUES (?,?,?,?,?,?)",
+		info.id,
+		info.accountId,
+		info.name,
+		info.pendingName,
+		false,
+		static_cast<uint32_t>(time(NULL)));
+}
+
+void MySQLDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET name = ?, pending_name = '', needs_rename = 0, last_login = ? WHERE id = ? LIMIT 1;", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void MySQLDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET pending_name = ?, needs_rename = 0, last_login = ? WHERE id = ? LIMIT 1", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void MySQLDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
+	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ? LIMIT 1", static_cast<uint32_t>(time(NULL)), characterId);
+}

dDatabase/GameDatabase/MySQL/Tables/CharXml.cpp

@@ -0,0 +1,19 @@
+#include "MySQLDatabase.h"
+
+std::string MySQLDatabase::GetCharacterXml(const uint32_t charId) {
+	auto result = ExecuteSelect("SELECT xml_data FROM charxml WHERE id = ? LIMIT 1;", charId);
+
+	if (!result->next()) {
+		return "";
+	}
+
+	return result->getString("xml_data").c_str();
+}
+
+void MySQLDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
+	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
+}
+
+void MySQLDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
+	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
+}

dDatabase/GameDatabase/MySQL/Tables/CommandLog.cpp

@@ -0,0 +1,5 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
+	ExecuteInsert("INSERT INTO command_log (character_id, command) VALUES (?, ?);", characterId, command);
+}

dDatabase/GameDatabase/MySQL/Tables/Friends.cpp

@@ -0,0 +1,73 @@
+#include "MySQLDatabase.h"
+
+std::vector<FriendData> MySQLDatabase::GetFriendsList(const uint32_t charId) {
+	auto friendsList = ExecuteSelect(
+		R"QUERY(
+			SELECT fr.requested_player AS player, best_friend AS bff, ci.name AS name FROM 
+			(
+				SELECT CASE 
+				WHEN player_id = ? THEN friend_id 
+				WHEN friend_id = ? THEN player_id 
+				END AS requested_player, best_friend FROM friends
+			) AS fr 
+			JOIN charinfo AS ci ON ci.id = fr.requested_player 
+			WHERE fr.requested_player IS NOT NULL AND fr.requested_player != ?;
+		)QUERY", charId, charId, charId);
+
+	std::vector<FriendData> toReturn;
+	toReturn.reserve(friendsList->rowsCount());
+
+	while (friendsList->next()) {
+		FriendData fd;
+		fd.friendID = friendsList->getUInt("player");
+		fd.isBestFriend = friendsList->getInt("bff") == 3; // 0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
+		fd.friendName = friendsList->getString("name").c_str();
+
+		toReturn.push_back(fd);
+	}
+
+	return toReturn;
+}
+
+std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	auto result = ExecuteSelect("SELECT * FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+
+	if (!result->next()) {
+		return std::nullopt;
+	}
+
+	IFriends::BestFriendStatus toReturn;
+	toReturn.playerCharacterId = result->getUInt("player_id");
+	toReturn.friendCharacterId = result->getUInt("friend_id");
+	toReturn.bestFriendStatus = result->getUInt("best_friend");
+
+	return toReturn;
+}
+
+void MySQLDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
+	ExecuteUpdate("UPDATE friends SET best_friend = ? WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
+		bestFriendStatus,
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}
+
+void MySQLDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	ExecuteInsert("INSERT IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
+}
+
+void MySQLDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	ExecuteDelete("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}

dDatabase/GameDatabase/MySQL/Tables/Leaderboard.cpp

@@ -0,0 +1,11 @@
+#include "MySQLDatabase.h"
+
+std::optional<uint32_t> MySQLDatabase::GetDonationTotal(const uint32_t activityId) {
+	auto donation_total = ExecuteSelect("SELECT SUM(primaryScore) as donation_total FROM leaderboard WHERE game_id = ?;", activityId);
+
+	if (!donation_total->next()) {
+		return std::nullopt;
+	}
+
+	return donation_total->getUInt("donation_total");
+}

dDatabase/GameDatabase/MySQL/Tables/Mail.cpp

@@ -0,0 +1,83 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::InsertNewMail(const IMail::MailInfo& mail) {
+	ExecuteInsert(
+		"INSERT INTO `mail` "
+		"(`sender_id`, `sender_name`, `receiver_id`, `receiver_name`, `time_sent`, `subject`, `body`, `attachment_id`, `attachment_lot`, `attachment_subkey`, `attachment_count`, `was_read`)"
+		" VALUES (?,?,?,?,?,?,?,?,?,?,?,0)",
+		mail.senderId,
+		mail.senderUsername,
+		mail.receiverId,
+		mail.recipient,
+		static_cast<uint32_t>(time(NULL)),
+		mail.subject,
+		mail.body,
+		mail.itemID,
+		mail.itemLOT,
+		0,
+		mail.itemCount);
+}
+
+std::vector<IMail::MailInfo> MySQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+	auto res = ExecuteSelect(
+		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
+		" FROM mail WHERE receiver_id=? limit ?;",
+		characterId, numberOfMail);
+
+	std::vector<IMail::MailInfo> toReturn;
+	toReturn.reserve(res->rowsCount());
+
+	while (res->next()) {
+		IMail::MailInfo mail;
+		mail.id = res->getUInt64("id");
+		mail.subject = res->getString("subject").c_str();
+		mail.body = res->getString("body").c_str();
+		mail.senderUsername = res->getString("sender_name").c_str();
+		mail.itemID = res->getUInt("attachment_id");
+		mail.itemLOT = res->getInt("attachment_lot");
+		mail.itemSubkey = res->getInt("attachment_subkey");
+		mail.itemCount = res->getInt("attachment_count");
+		mail.timeSent = res->getUInt64("time_sent");
+		mail.wasRead = res->getBoolean("was_read");
+
+		toReturn.push_back(std::move(mail));
+	}
+
+	return toReturn;
+}
+
+std::optional<IMail::MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
+	auto res = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
+
+	if (!res->next()) {
+		return std::nullopt;
+	}
+
+	IMail::MailInfo toReturn;
+	toReturn.itemLOT = res->getInt("attachment_lot");
+	toReturn.itemCount = res->getInt("attachment_count");
+
+	return toReturn;
+}
+
+uint32_t MySQLDatabase::GetUnreadMailCount(const uint32_t characterId) {
+	auto res = ExecuteSelect("SELECT COUNT(*) AS number_unread FROM mail WHERE receiver_id=? AND was_read=0;", characterId);
+
+	if (!res->next()) {
+		return 0;
+	}
+
+	return res->getInt("number_unread");
+}
+
+void MySQLDatabase::MarkMailRead(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET was_read=1 WHERE id=? LIMIT 1;", mailId);
+}
+
+void MySQLDatabase::ClaimMailItem(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET attachment_lot=0 WHERE id=? LIMIT 1;", mailId);
+}
+
+void MySQLDatabase::DeleteMail(const uint64_t mailId) {
+	ExecuteDelete("DELETE FROM mail WHERE id=? LIMIT 1;", mailId);
+}

dDatabase/GameDatabase/MySQL/Tables/MigrationHistory.cpp

@@ -0,0 +1,13 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::CreateMigrationHistoryTable() {
+	ExecuteInsert("CREATE TABLE IF NOT EXISTS migration_history (name TEXT NOT NULL, date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP());");
+}
+
+bool MySQLDatabase::IsMigrationRun(const std::string_view str) {
+	return ExecuteSelect("SELECT name FROM migration_history WHERE name = ?;", str)->next();
+}
+
+void MySQLDatabase::InsertMigration(const std::string_view str) {
+	ExecuteInsert("INSERT INTO migration_history (name) VALUES (?);", str);
+}

dDatabase/GameDatabase/MySQL/Tables/ObjectIdTracker.cpp

@@ -0,0 +1,17 @@
+#include "MySQLDatabase.h"
+
+std::optional<uint32_t> MySQLDatabase::GetCurrentPersistentId() {
+	auto result = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
+	if (!result->next()) {
+		return std::nullopt;
+	}
+	return result->getUInt("last_object_id");
+}
+
+void MySQLDatabase::InsertDefaultPersistentId() {
+	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
+}
+
+void MySQLDatabase::UpdatePersistentId(const uint32_t newId) {
+	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
+}

dDatabase/GameDatabase/MySQL/Tables/PetNames.cpp

@@ -0,0 +1,26 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO `pet_names` (`id`, `pet_name`, `approved`) VALUES (?, ?, ?) "
+		"ON DUPLICATE KEY UPDATE pet_name = ?, approved = ?;",
+		petId,
+		info.petName,
+		info.approvalStatus,
+		info.petName,
+		info.approvalStatus);
+}
+
+std::optional<IPetNames::Info> MySQLDatabase::GetPetNameInfo(const LWOOBJID& petId) {
+	auto result = ExecuteSelect("SELECT pet_name, approved FROM pet_names WHERE id = ? LIMIT 1;", petId);
+
+	if (!result->next()) {
+		return std::nullopt;
+	}
+
+	IPetNames::Info toReturn;
+	toReturn.petName = result->getString("pet_name").c_str();
+	toReturn.approvalStatus = result->getInt("approved");
+
+	return toReturn;
+}

dDatabase/GameDatabase/MySQL/Tables/PlayKeys.cpp

@@ -0,0 +1,11 @@
+#include "MySQLDatabase.h"
+
+std::optional<bool> MySQLDatabase::IsPlaykeyActive(const int32_t playkeyId) {
+	auto keyCheckRes = ExecuteSelect("SELECT active FROM `play_keys` WHERE id=?", playkeyId);
+
+	if (!keyCheckRes->next()) {
+		return std::nullopt;
+	}
+
+	return keyCheckRes->getBoolean("active");
+}

dDatabase/GameDatabase/MySQL/Tables/PlayerCheatDetections.cpp

@@ -0,0 +1,7 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::InsertCheatDetection(const IPlayerCheatDetections::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO player_cheat_detections (account_id, name, violation_msg, violation_system_address) VALUES (?, ?, ?, ?)",
+		info.userId, info.username, info.extraMessage, info.systemAddress);
+}

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -0,0 +1,57 @@
+#include "MySQLDatabase.h"
+
+std::optional<IProperty::Info> MySQLDatabase::GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) {
+	auto propertyEntry = ExecuteSelect(
+		"SELECT id, owner_id, clone_id, name, description, privacy_option, rejection_reason, last_updated, time_claimed, reputation, mod_approved "
+		"FROM properties WHERE zone_id = ? AND clone_id = ?;", mapId, cloneId);
+
+	if (!propertyEntry->next()) {
+		return std::nullopt;
+	}
+
+	IProperty::Info toReturn;
+	toReturn.id = propertyEntry->getUInt64("id");
+	toReturn.ownerId = propertyEntry->getUInt64("owner_id");
+	toReturn.cloneId = propertyEntry->getUInt64("clone_id");
+	toReturn.name = propertyEntry->getString("name").c_str();
+	toReturn.description = propertyEntry->getString("description").c_str();
+	toReturn.privacyOption = propertyEntry->getInt("privacy_option");
+	toReturn.rejectionReason = propertyEntry->getString("rejection_reason").c_str();
+	toReturn.lastUpdatedTime = propertyEntry->getUInt("last_updated");
+	toReturn.claimedTime = propertyEntry->getUInt("time_claimed");
+	toReturn.reputation = propertyEntry->getUInt("reputation");
+	toReturn.modApproved = propertyEntry->getUInt("mod_approved");
+
+	return toReturn;
+}
+
+void MySQLDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET privacy_option = ?, rejection_reason = ?, mod_approved = ? WHERE id = ? LIMIT 1;",
+		info.privacyOption,
+		info.rejectionReason,
+		info.modApproved,
+		info.id);
+}
+
+void MySQLDatabase::UpdatePropertyDetails(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET name = ?, description = ? WHERE id = ? LIMIT 1;", info.name, info.description, info.id);
+}
+
+void MySQLDatabase::UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) {
+	ExecuteUpdate("UPDATE properties SET performance_cost = ? WHERE zone_id = ? AND clone_id = ? LIMIT 1;", performanceCost, zoneId.GetMapID(), zoneId.GetCloneID());
+}
+
+void MySQLDatabase::InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) {
+	auto insertion = ExecuteInsert(
+		"INSERT INTO properties"
+		"(id, owner_id, template_id, clone_id, name, description, zone_id, rent_amount, rent_due, privacy_option, last_updated, time_claimed, rejection_reason, reputation, performance_cost)"
+		"VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, 0, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), '', 0, 0.0)",
+		info.id,
+		info.ownerId,
+		templateId,
+		zoneId.GetCloneID(),
+		info.name,
+		info.description,
+		zoneId.GetMapID()
+	);
+}

dDatabase/GameDatabase/MySQL/Tables/PropertyContents.cpp

@@ -0,0 +1,54 @@
+#include "MySQLDatabase.h"
+
+std::vector<IPropertyContents::Model> MySQLDatabase::GetPropertyModels(const LWOOBJID& propertyId) {
+	auto result = ExecuteSelect("SELECT id, lot, x, y, z, rx, ry, rz, rw, ugc_id FROM properties_contents WHERE property_id = ?;", propertyId);
+
+	std::vector<IPropertyContents::Model> toReturn;
+	toReturn.reserve(result->rowsCount());
+	while (result->next()) {
+		IPropertyContents::Model model;
+		model.id = result->getUInt64("id");
+		model.lot = static_cast<LOT>(result->getUInt("lot"));
+		model.position.x = result->getFloat("x");
+		model.position.y = result->getFloat("y");
+		model.position.z = result->getFloat("z");
+		model.rotation.w = result->getFloat("rw");
+		model.rotation.x = result->getFloat("rx");
+		model.rotation.y = result->getFloat("ry");
+		model.rotation.z = result->getFloat("rz");
+		model.ugcId = result->getUInt64("ugc_id");
+		toReturn.push_back(std::move(model));
+	}
+	return toReturn;
+}
+
+void MySQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) {
+	try {
+		ExecuteInsert(
+			"INSERT INTO properties_contents"
+			"(id, property_id, ugc_id, lot, x, y, z, rx, ry, rz, rw, model_name, model_description, behavior_1, behavior_2, behavior_3, behavior_4, behavior_5)"
+			"VALUES (?,  ?,           ?,      ?,   ?, ?, ?, ?,  ?,  ?,  ?,  ?,    ?,           ?,          ?,          ?,          ?,          ?)",
+			//       1,  2,           3,      4,   5, 6, 7, 8,  9,  10, 11, 12,   13,          14,         15,         16,         17          18
+			model.id, propertyId, model.ugcId == 0 ? std::nullopt : std::optional(model.ugcId), static_cast<uint32_t>(model.lot),
+			model.position.x, model.position.y, model.position.z, model.rotation.x, model.rotation.y, model.rotation.z, model.rotation.w,
+			name, "", // Model description.  TODO implement this.
+			0, // behavior 1.  TODO implement this.
+			0, // behavior 2.  TODO implement this.
+			0, // behavior 3.  TODO implement this.
+			0, // behavior 4.  TODO implement this.
+			0 // behavior 5.  TODO implement this.
+		);
+	} catch (sql::SQLException& e) {
+		LOG("Error inserting new property model: %s", e.what());
+	}
+}
+
+void MySQLDatabase::UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) {
+	ExecuteUpdate(
+		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ? WHERE id = ?;",
+		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w, propertyId);
+}
+
+void MySQLDatabase::RemoveModel(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
+}

dDatabase/GameDatabase/MySQL/Tables/Servers.cpp

@@ -0,0 +1,23 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::SetMasterIp(const std::string_view ip, const uint32_t port) {
+	// We only want our 1 entry anyways, so we can just delete all and reinsert the one we want
+	// since it would be two queries anyways.
+	ExecuteDelete("TRUNCATE TABLE servers;");
+	ExecuteInsert("INSERT INTO `servers` (`name`, `ip`, `port`, `state`, `version`) VALUES ('master', ?, ?, 0, 171022)", ip, port);
+}
+
+std::optional<IServers::MasterInfo> MySQLDatabase::GetMasterInfo() {
+	auto result = ExecuteSelect("SELECT ip, port FROM servers WHERE name='master' LIMIT 1;");
+
+	if (!result->next()) {
+		return std::nullopt;
+	}
+
+	MasterInfo toReturn;
+
+	toReturn.ip = result->getString("ip").c_str();
+	toReturn.port = result->getInt("port");
+
+	return toReturn;
+}

dDatabase/GameDatabase/MySQL/Tables/Ugc.cpp

@@ -0,0 +1,71 @@
+#include "MySQLDatabase.h"
+
+std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId) {
+	auto result = ExecuteSelect(
+		"SELECT lxfml, u.id FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
+		propertyId);
+
+	std::vector<IUgc::Model> toReturn;
+
+	while (result->next()) {
+		IUgc::Model model;
+
+		// blob is owned by the query, so we need to do a deep copy :/
+		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
+		model.lxfmlData << blob->rdbuf();
+		model.id = result->getUInt64("id");
+		toReturn.push_back(std::move(model));
+	}
+
+	return toReturn;
+}
+
+std::vector<IUgc::Model> MySQLDatabase::GetAllUgcModels() {
+	auto result = ExecuteSelect("SELECT id, lxfml FROM ugc;");
+
+	std::vector<IUgc::Model> models;
+	models.reserve(result->rowsCount());
+	while (result->next()) {
+		IUgc::Model model;
+		model.id = result->getInt64("id");
+
+		// blob is owned by the query, so we need to do a deep copy :/
+		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
+		model.lxfmlData << blob->rdbuf();
+		models.push_back(std::move(model));
+	}
+
+	return models;
+}
+
+void MySQLDatabase::RemoveUnreferencedUgcModels() {
+	ExecuteDelete("DELETE FROM ugc WHERE id NOT IN (SELECT ugc_id FROM properties_contents WHERE ugc_id IS NOT NULL);");
+}
+
+void MySQLDatabase::InsertNewUgcModel(
+	std::istringstream& sd0Data, // cant be const sad
+	const uint32_t blueprintId,
+	const uint32_t accountId,
+	const uint32_t characterId) {
+	const std::istream stream(sd0Data.rdbuf());
+	ExecuteInsert(
+		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
+		blueprintId,
+		accountId,
+		characterId,
+		0,
+		&stream,
+		false,
+		"weedeater.lxfml"
+	);
+}
+
+void MySQLDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM ugc WHERE id = ?;", modelId);
+	ExecuteDelete("DELETE FROM properties_contents WHERE ugc_id = ?;", modelId);
+}
+
+void MySQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
+	const std::istream stream(lxfml.rdbuf());
+	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
+}