feat: allow SQLite database backend (#1663)

* simplify leaderboard code, fully abstract database

* update exception catching

* update exception catching and sql references, remove ugc from gamemessages

fix deleting model

remove unrelated changes

Update GameMessages.cpp

* remove ugc from gamemessages

* Update GameMessages.cpp

* Update Leaderboard.cpp

* bug fixes

* fix racing leaderboard

* remove extra stuff

* update

* add sqlite

* use a default for optimizations

* update sqlite

* Fix limits on update and delete

* fix bugs

* use definition to switch between databases

* add switch for different backends

* fix include guard and includes

* always build both

* add mysql if block

* Update Database.cpp

* add new options and add check to prevent overriding mysql

* correct config names

* Update README.md

* Update README.md

* merge to 1 sql file for sqlite database

* move to sqlite folder

* add back mysql migrations

* Update README.md

* add migration to correct the folder name or mysql

* yes aron

* updates

* Update CMakeLists.txt

* dont use paths at all, add where check to only update if folder name still exist

check also doesnt check for slashes and assumes one will be there since it will be.

* default dont auto create account

for releases we can change this flag

* default 0

* add times played query

* fix leaderboard not incrementing on a not better score

* add env vars with defaults for docker

* use an "enum"

* default to mariadb

* Update .env.example

dDatabase/GameDatabase/CMakeLists.txt

@@ -8,6 +8,12 @@ foreach(file ${DDATABSE_DATABSES_MYSQL_SOURCES})
 	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "MySQL/${file}")
 endforeach()
 
+add_subdirectory(SQLite)
+
+foreach(file ${DDATABSE_DATABSES_SQLITE_SOURCES})
+	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "SQLite/${file}")
+endforeach()
+
 add_subdirectory(TestSQL)
 
 foreach(file ${DDATABSE_DATABSES_TEST_SQL_SOURCES})
@@ -16,13 +22,14 @@ endforeach()
 
 add_library(dDatabaseGame STATIC ${DDATABASE_GAMEDATABASE_SOURCES})
 target_include_directories(dDatabaseGame PUBLIC "."
-	"ITables" PRIVATE "MySQL" "TestSQL"
+	"ITables" PRIVATE "MySQL" "SQLite" "TestSQL"
 	"${PROJECT_SOURCE_DIR}/dCommon"
 	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
 )
+
 target_link_libraries(dDatabaseGame
-	PUBLIC MariaDB::ConnCpp
-	INTERFACE dCommon)
+	INTERFACE dCommon
+	PRIVATE sqlite3 MariaDB::ConnCpp)
 
 # Glob together all headers that need to be precompiled
 file(

dDatabase/GameDatabase/Database.cpp

@@ -2,22 +2,46 @@
 #include "Game.h"
 #include "dConfig.h"
 #include "Logger.h"
-#include "MySQLDatabase.h"
 #include "DluAssert.h"
 
+#include "SQLiteDatabase.h"
+#include "MySQLDatabase.h"
+
+#include <ranges>
+
 #pragma warning (disable:4251) //Disables SQL warnings
 
 namespace {
 	GameDatabase* database = nullptr;
 }
 
+std::string Database::GetMigrationFolder() {
+	const std::set<std::string> validMysqlTypes = { "mysql", "mariadb", "maria" };
+	auto databaseType = Game::config->GetValue("database_type");
+	std::ranges::transform(databaseType, databaseType.begin(), ::tolower);
+	if (databaseType == "sqlite") return "sqlite";
+	else if (validMysqlTypes.contains(databaseType)) return "mysql";
+	else {
+		LOG("No database specified, using MySQL");
+		return "mysql";
+	}
+}
+
 void Database::Connect() {
 	if (database) {
 		LOG("Tried to connect to database when it's already connected!");
 		return;
 	}
 
-	database = new MySQLDatabase();
+	const auto databaseType = GetMigrationFolder();
+
+	if (databaseType == "sqlite") database = new SQLiteDatabase();
+	else if (databaseType == "mysql") database = new MySQLDatabase();
+	else {
+		LOG("Invalid database type specified in config, using MySQL");
+		database = new MySQLDatabase();
+	}
+
 	database->Connect();
 }
 

dDatabase/GameDatabase/Database.h

@@ -12,4 +12,6 @@ namespace Database {
 	// Used for assigning a test database as the handler for database logic.
 	// Do not use in production code.
 	void _setDatabase(GameDatabase* const db);
+
+	std::string GetMigrationFolder();
 };

dDatabase/GameDatabase/GameDatabase.h

@@ -26,13 +26,8 @@
 #include "IBehaviors.h"
 #include "IUgcModularBuild.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)
+#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (std::exception& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
 #else
 #  define DLU_SQL_TRY_CATCH_RETHROW(x) x
 #endif // _DEBUG
@@ -50,7 +45,6 @@ public:
 	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;

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -36,6 +36,8 @@ public:
 
 	// Update the GameMaster level of an account.
 	virtual void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) = 0;
+
+	virtual uint32_t GetAccountCount() = 0;
 };
 
 #endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -14,6 +14,7 @@ namespace {
 };
 
 void MySQLDatabase::Connect() {
+	LOG("Using MySQL database");
 	driver = sql::mariadb::get_driver_instance();
 
 	// The mariadb connector is *supposed* to handle unix:// and pipe:// prefixes to hostName, but there are bugs where
@@ -67,7 +68,7 @@ void MySQLDatabase::ExecuteCustomQuery(const std::string_view query) {
 
 sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& query) {
 	if (!con) {
-		Connect();
+		Database::Get()->Connect();
 		LOG("Trying to reconnect to MySQL");
 	}
 
@@ -76,7 +77,7 @@ sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& quer
 
 		con = nullptr;
 
-		Connect();
+		Database::Get()->Connect();
 		LOG("Trying to reconnect to MySQL from invalid or closed connection");
 	}
 

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -30,7 +30,6 @@ 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;
@@ -125,6 +124,8 @@ public:
 	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
+	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
+	uint32_t GetAccountCount() override;
 private:
 
 	// Generic query functions that can be used for any query.

dDatabase/GameDatabase/MySQL/Tables/Accounts.cpp

@@ -39,3 +39,8 @@ void MySQLDatabase::InsertNewAccount(const std::string_view username, const std:
 void MySQLDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) {
 	ExecuteUpdate("UPDATE accounts SET gm_level = ? WHERE id = ?;", static_cast<int32_t>(gmLevel), accountId);
 }
+
+uint32_t MySQLDatabase::GetAccountCount() {
+	auto res = ExecuteSelect("SELECT COUNT(*) as count FROM accounts;");
+	return res->next() ? res->getUInt("count") : 0;
+}

dDatabase/GameDatabase/SQLite/CMakeLists.txt

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

dDatabase/GameDatabase/SQLite/SQLiteDatabase.cpp

@@ -0,0 +1,73 @@
+#include "SQLiteDatabase.h"
+
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "Logger.h"
+#include "dPlatforms.h"
+
+// Static Variables
+
+// Status Variables
+namespace {
+	CppSQLite3DB* con = nullptr;
+	bool isConnected = false;
+};
+
+void SQLiteDatabase::Connect() {
+	LOG("Using SQLite database");
+	con = new CppSQLite3DB();
+	con->open(Game::config->GetValue("sqlite_database_path").c_str());
+	isConnected = true;
+
+	// Make sure wal is enabled for the database.
+	con->execQuery("PRAGMA journal_mode = WAL;");
+}
+
+void SQLiteDatabase::Destroy(std::string source) {
+	if (!con) return;
+
+	if (source.empty()) LOG("Destroying SQLite connection!");
+	else LOG("Destroying SQLite connection from %s!", source.c_str());
+
+	con->close();
+	delete con;
+	con = nullptr;
+}
+
+void SQLiteDatabase::ExecuteCustomQuery(const std::string_view query) {
+	con->compileStatement(query.data()).execDML();
+}
+
+CppSQLite3Statement SQLiteDatabase::CreatePreppedStmt(const std::string& query) {
+	return con->compileStatement(query.c_str());
+}
+
+void SQLiteDatabase::Commit() {
+	if (!con->IsAutoCommitOn()) con->compileStatement("COMMIT;").execDML();
+}
+
+bool SQLiteDatabase::GetAutoCommit() {
+	return con->IsAutoCommitOn();
+}
+
+void SQLiteDatabase::SetAutoCommit(bool value) {
+	if (value) {
+		if (GetAutoCommit()) con->compileStatement("BEGIN;").execDML();
+	} else {
+		if (!GetAutoCommit()) con->compileStatement("COMMIT;").execDML();
+	}
+}
+
+void SQLiteDatabase::DeleteCharacter(const uint32_t characterId) {
+	ExecuteDelete("DELETE FROM charxml WHERE id=?;", 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=?;", characterId);
+}

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -0,0 +1,270 @@
+#ifndef SQLITEDATABASE_H
+#define SQLITEDATABASE_H
+
+#include "CppSQLite3.h"
+
+#include "GameDatabase.h"
+
+using PreppedStmtRef = CppSQLite3Statement&;
+
+// 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(PreppedStmtRef 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(PreppedStmtRef stmt, Args&&... args) {
+	if constexpr (sizeof...(args) != 0) {
+		int i = 1;
+		(SetParam(stmt, i++, args), ...);
+	}
+}
+
+class SQLiteDatabase : public GameDatabase {
+public:
+	void Connect() override;
+	void Destroy(std::string source = "") 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 UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) 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;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
+	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
+	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
+	void AddBehavior(const IBehaviors::Info& info) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t characterId) override;
+	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
+	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override;
+	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override;
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
+	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
+	void DeleteUgcBuild(const LWOOBJID bigId) override;
+	uint32_t GetAccountCount() override;
+private:
+	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
+
+	// 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::pair<CppSQLite3Statement, CppSQLite3Query> ExecuteSelect(const std::string& query, Args&&... args) {
+		std::pair<CppSQLite3Statement, CppSQLite3Query> toReturn;
+		toReturn.first = CreatePreppedStmt(query);
+		SetParams(toReturn.first, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(toReturn.second = toReturn.first.execQuery());
+		return toReturn;
+	}
+
+	template<typename... Args>
+	inline void ExecuteDelete(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(preppedStmt.execDML());
+	}
+
+	template<typename... Args>
+	inline int32_t ExecuteUpdate(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt.execDML());
+	}
+
+	template<typename... Args>
+	inline int ExecuteInsert(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt.execDML());
+	}
+};
+
+// Below are each of the definitions of SetParam for each supported type.
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::string_view param) {
+	LOG("%s", param.data());
+	stmt.bind(index, param.data());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const char* param) {
+	LOG("%s", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::string param) {
+	LOG("%s", param.c_str());
+	stmt.bind(index, param.c_str());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int8_t param) {
+	LOG("%u", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint8_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int16_t param) {
+	LOG("%u", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint16_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint32_t param) {
+	LOG("%u", param);
+	stmt.bind(index, static_cast<int32_t>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int32_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int64_t param) {
+	LOG("%llu", param);
+	stmt.bind(index, static_cast<sqlite_int64>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint64_t param) {
+	LOG("%llu", param);
+	stmt.bind(index, static_cast<sqlite_int64>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const float param) {
+	LOG("%f", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const double param) {
+	LOG("%f", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const bool param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::istream* param) {
+	LOG("Blob");
+	// This is the one time you will ever see me use const_cast.
+	std::stringstream stream;
+	stream << param->rdbuf();
+	stmt.bind(index, reinterpret_cast<const unsigned char*>(stream.str().c_str()), stream.str().size());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
+	if (param) {
+		LOG("%d", param.value());
+		stmt.bind(index, static_cast<int>(param.value()));
+	} else {
+		LOG("Null");
+		stmt.bindNull(index);
+	}
+}
+
+#endif  //!SQLITEDATABASE_H

dDatabase/GameDatabase/SQLite/Tables/Accounts.cpp

@@ -0,0 +1,49 @@
+#include "SQLiteDatabase.h"
+
+#include "eGameMasterLevel.h"
+#include "Database.h"
+
+std::optional<IAccounts::Info> SQLiteDatabase::GetAccountInfo(const std::string_view username) {
+	auto [_, result] = ExecuteSelect("SELECT * FROM accounts WHERE name = ? LIMIT 1", username);
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	IAccounts::Info toReturn;
+	toReturn.id = result.getIntField("id");
+	toReturn.maxGmLevel = static_cast<eGameMasterLevel>(result.getIntField("gm_level"));
+	toReturn.bcryptPassword = result.getStringField("password");
+	toReturn.banned = result.getIntField("banned");
+	toReturn.locked = result.getIntField("locked");
+	toReturn.playKeyId = result.getIntField("play_key_id");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) {
+	ExecuteUpdate("UPDATE accounts SET mute_expire = ? WHERE id = ?;", timeToUnmute, accountId);
+}
+
+void SQLiteDatabase::UpdateAccountBan(const uint32_t accountId, const bool banned) {
+	ExecuteUpdate("UPDATE accounts SET banned = ? WHERE id = ?;", banned, accountId);
+}
+
+void SQLiteDatabase::UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) {
+	ExecuteUpdate("UPDATE accounts SET password = ? WHERE id = ?;", bcryptpassword, accountId);
+}
+
+void SQLiteDatabase::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));
+}
+
+void SQLiteDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) {
+	ExecuteUpdate("UPDATE accounts SET gm_level = ? WHERE id = ?;", static_cast<int32_t>(gmLevel), accountId);
+}
+
+uint32_t SQLiteDatabase::GetAccountCount() {
+	auto [_, res] = ExecuteSelect("SELECT COUNT(*) as count FROM accounts;");
+	if (res.eof()) return 0;
+
+	return res.getIntField("count");
+}

dDatabase/GameDatabase/SQLite/Tables/AccountsRewardCodes.cpp

@@ -0,0 +1,17 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) {
+	ExecuteInsert("INSERT OR IGNORE INTO accounts_rewardcodes (account_id, rewardcode) VALUES (?, ?);", account_id, reward_code);
+}
+
+std::vector<uint32_t> SQLiteDatabase::GetRewardCodesByAccountID(const uint32_t account_id) {
+	auto [_, result] = ExecuteSelect("SELECT rewardcode FROM accounts_rewardcodes WHERE account_id = ?;", account_id);
+
+	std::vector<uint32_t> toReturn;
+	while (!result.eof()) {
+		toReturn.push_back(result.getIntField("rewardcode"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/ActivityLog.cpp

@@ -0,0 +1,6 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::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/SQLite/Tables/Behaviors.cpp

@@ -0,0 +1,19 @@
+#include "IBehaviors.h"
+
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::AddBehavior(const IBehaviors::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO behaviors (behavior_info, character_id, behavior_id) VALUES (?, ?, ?) ON CONFLICT(behavior_id) DO UPDATE SET behavior_info = ?",
+		info.behaviorInfo, info.characterId, info.behaviorId, info.behaviorInfo
+	);
+}
+
+void SQLiteDatabase::RemoveBehavior(const int32_t behaviorId) {
+	ExecuteDelete("DELETE FROM behaviors WHERE behavior_id = ?", behaviorId);
+}
+
+std::string SQLiteDatabase::GetBehavior(const int32_t behaviorId) {
+	auto [_, result] = ExecuteSelect("SELECT behavior_info FROM behaviors WHERE behavior_id = ?", behaviorId);
+	return !result.eof() ? result.getStringField("behavior_info") : "";
+}

dDatabase/GameDatabase/SQLite/Tables/BugReports.cpp

@@ -0,0 +1,6 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::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/SQLite/Tables/CMakeLists.txt

@@ -0,0 +1,26 @@
+set(DDATABASES_DATABASES_SQLITE_TABLES_SOURCES
+	"Accounts.cpp"
+	"AccountsRewardCodes.cpp"
+	"ActivityLog.cpp"
+	"Behaviors.cpp"
+	"BugReports.cpp"
+	"CharInfo.cpp"
+	"CharXml.cpp"
+	"CommandLog.cpp"
+	"Friends.cpp"
+	"IgnoreList.cpp"
+	"Leaderboard.cpp"
+	"Mail.cpp"
+	"MigrationHistory.cpp"
+	"ObjectIdTracker.cpp"
+	"PetNames.cpp"
+	"PlayerCheatDetections.cpp"
+	"PlayKeys.cpp"
+	"Property.cpp"
+	"PropertyContents.cpp"
+	"Servers.cpp"
+	"Ugc.cpp"
+	"UgcModularBuild.cpp"
+	PARENT_SCOPE
+)
+

dDatabase/GameDatabase/SQLite/Tables/CharInfo.cpp

@@ -0,0 +1,79 @@
+#include "SQLiteDatabase.h"
+
+std::vector<std::string> SQLiteDatabase::GetApprovedCharacterNames() {
+	auto [_, result] = ExecuteSelect("SELECT name FROM charinfo;");
+
+	std::vector<std::string> toReturn;
+
+	while (!result.eof()) {
+		toReturn.push_back(result.getStringField("name"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> CharInfoFromQueryResult(CppSQLite3Query stmt) {
+	if (stmt.eof()) {
+		return std::nullopt;
+	}
+
+	ICharInfo::Info toReturn;
+
+	toReturn.id = stmt.getIntField("id");
+	toReturn.name = stmt.getStringField("name");
+	toReturn.pendingName = stmt.getStringField("pending_name");
+	toReturn.needsRename = stmt.getIntField("needs_rename");
+	toReturn.cloneId = stmt.getInt64Field("prop_clone_id");
+	toReturn.accountId = stmt.getIntField("account_id");
+	toReturn.permissionMap = static_cast<ePermissionMap>(stmt.getIntField("permission_map"));
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> SQLiteDatabase::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).second
+	);
+}
+
+std::optional<ICharInfo::Info> SQLiteDatabase::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).second
+	);
+}
+
+std::vector<uint32_t> SQLiteDatabase::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;
+	while (!result.eof()) {
+		toReturn.push_back(result.getIntField("id"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+void SQLiteDatabase::InsertNewCharacter(const ICharInfo::Info info) {
+	ExecuteInsert(
+		"INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`, `prop_clone_id`) VALUES (?,?,?,?,?,?,(SELECT IFNULL(MAX(`prop_clone_id`), 0) + 1 FROM `charinfo`))",
+		info.id,
+		info.accountId,
+		info.name,
+		info.pendingName,
+		false,
+		static_cast<uint32_t>(time(NULL)));
+}
+
+void SQLiteDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET name = ?, pending_name = '', needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void SQLiteDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET pending_name = ?, needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void SQLiteDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
+	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ?;", static_cast<uint32_t>(time(NULL)), characterId);
+}

dDatabase/GameDatabase/SQLite/Tables/CharXml.cpp

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

dDatabase/GameDatabase/SQLite/Tables/CommandLog.cpp

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

dDatabase/GameDatabase/SQLite/Tables/Friends.cpp

@@ -0,0 +1,73 @@
+#include "SQLiteDatabase.h"
+
+std::vector<FriendData> SQLiteDatabase::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;
+
+	while (!friendsList.eof()) {
+		FriendData fd;
+		fd.friendID = friendsList.getIntField("player");
+		fd.isBestFriend = friendsList.getIntField("bff") == 3; // 0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
+		fd.friendName = friendsList.getStringField("name");
+
+		toReturn.push_back(fd);
+		friendsList.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<IFriends::BestFriendStatus> SQLiteDatabase::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.eof()) {
+		return std::nullopt;
+	}
+
+	IFriends::BestFriendStatus toReturn;
+	toReturn.playerCharacterId = result.getIntField("player_id");
+	toReturn.friendCharacterId = result.getIntField("friend_id");
+	toReturn.bestFriendStatus = result.getIntField("best_friend");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::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 = ?);",
+		bestFriendStatus,
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}
+
+void SQLiteDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	ExecuteInsert("INSERT OR IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
+}
+
+void SQLiteDatabase::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 = ?);",
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}

dDatabase/GameDatabase/SQLite/Tables/IgnoreList.cpp

@@ -0,0 +1,22 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IIgnoreList::Info> SQLiteDatabase::GetIgnoreList(const uint32_t playerId) {
+	auto [_, result] = ExecuteSelect("SELECT ci.name AS name, il.ignored_player_id AS ignore_id FROM ignore_list AS il JOIN charinfo AS ci ON il.ignored_player_id = ci.id WHERE il.player_id = ?", playerId);
+
+	std::vector<IIgnoreList::Info> ignoreList;
+
+	while (!result.eof()) {
+		ignoreList.push_back(IIgnoreList::Info{ result.getStringField("name"), static_cast<uint32_t>(result.getIntField("ignore_id")) });
+		result.nextRow();
+	}
+
+	return ignoreList;
+}
+
+void SQLiteDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteInsert("INSERT OR IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
+}
+
+void SQLiteDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteDelete("DELETE FROM ignore_list WHERE player_id = ? AND ignored_player_id = ?", playerId, ignoredPlayerId);
+}

dDatabase/GameDatabase/SQLite/Tables/Leaderboard.cpp

@@ -0,0 +1,91 @@
+#include "SQLiteDatabase.h"
+
+#include "Game.h"
+#include "Logger.h"
+#include "dConfig.h"
+
+std::optional<uint32_t> SQLiteDatabase::GetDonationTotal(const uint32_t activityId) {
+	auto [_, donation_total] = ExecuteSelect("SELECT SUM(primaryScore) as donation_total FROM leaderboard WHERE game_id = ?;", activityId);
+
+	if (donation_total.eof()) {
+		return std::nullopt;
+	}
+
+	return donation_total.getIntField("donation_total");
+}
+
+std::vector<ILeaderboard::Entry> ProcessQuery(CppSQLite3Query& rows) {
+	std::vector<ILeaderboard::Entry> entries;
+
+	while (!rows.eof()) {
+		auto& entry = entries.emplace_back();
+
+		entry.charId = rows.getIntField("character_id");
+		entry.lastPlayedTimestamp = rows.getIntField("lp_unix");
+		entry.primaryScore = rows.getFloatField("primaryScore");
+		entry.secondaryScore = rows.getFloatField("secondaryScore");
+		entry.tertiaryScore = rows.getFloatField("tertiaryScore");
+		entry.numWins = rows.getIntField("numWins");
+		entry.numTimesPlayed = rows.getIntField("timesPlayed");
+		entry.name = rows.getStringField("char_name");
+		// entry.ranking is never set because its calculated in leaderboard in code.
+		rows.nextRow();
+	}
+
+	return entries;
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetDescendingLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetAscendingLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore ASC, secondaryscore ASC, tertiaryScore ASC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetAgsLeaderboard(const uint32_t activityId) {
+	auto query = Game::config->GetValue("classic_survival_scoring") != "1" ? 
+	"SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;" : 
+	"SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY secondaryscore DESC, primaryscore DESC, tertiaryScore DESC, last_played ASC;";
+	auto [_, result] = ExecuteSelect(query, activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetNsLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore ASC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+void SQLiteDatabase::SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("INSERT INTO leaderboard (primaryScore, secondaryScore, tertiaryScore, character_id, game_id, last_played) VALUES (?,?,?,?,?,CURRENT_TIMESTAMP) ;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+void SQLiteDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("UPDATE leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
+	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
+	auto [_, res] = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+	if (!res.eof()) {
+		toReturn = ILeaderboard::Score{
+			.primaryScore = static_cast<float>(res.getFloatField("primaryScore")),
+			.secondaryScore = static_cast<float>(res.getFloatField("secondaryScore")),
+			.tertiaryScore = static_cast<float>(res.getFloatField("tertiaryScore"))
+		};
+	}
+
+	return toReturn;
+}
+
+void SQLiteDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET numWins = numWins + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}
+
+void SQLiteDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}

dDatabase/GameDatabase/SQLite/Tables/Mail.cpp

@@ -0,0 +1,83 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::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> SQLiteDatabase::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;
+
+	while (!res.eof()) {
+		IMail::MailInfo mail;
+		mail.id = res.getInt64Field("id");
+		mail.subject = res.getStringField("subject");
+		mail.body = res.getStringField("body");
+		mail.senderUsername = res.getStringField("sender_name");
+		mail.itemID = res.getIntField("attachment_id");
+		mail.itemLOT = res.getIntField("attachment_lot");
+		mail.itemSubkey = res.getIntField("attachment_subkey");
+		mail.itemCount = res.getIntField("attachment_count");
+		mail.timeSent = res.getInt64Field("time_sent");
+		mail.wasRead = res.getIntField("was_read");
+
+		toReturn.push_back(std::move(mail));
+		res.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<IMail::MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
+	auto [_, res] = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
+
+	if (res.eof()) {
+		return std::nullopt;
+	}
+
+	IMail::MailInfo toReturn;
+	toReturn.itemLOT = res.getIntField("attachment_lot");
+	toReturn.itemCount = res.getIntField("attachment_count");
+
+	return toReturn;
+}
+
+uint32_t SQLiteDatabase::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.eof()) {
+		return 0;
+	}
+
+	return res.getIntField("number_unread");
+}
+
+void SQLiteDatabase::MarkMailRead(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET was_read=1 WHERE id=?;", mailId);
+}
+
+void SQLiteDatabase::ClaimMailItem(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET attachment_lot=0 WHERE id=?;", mailId);
+}
+
+void SQLiteDatabase::DeleteMail(const uint64_t mailId) {
+	ExecuteDelete("DELETE FROM mail WHERE id=?;", mailId);
+}

dDatabase/GameDatabase/SQLite/Tables/MigrationHistory.cpp

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

dDatabase/GameDatabase/SQLite/Tables/ObjectIdTracker.cpp

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

dDatabase/GameDatabase/SQLite/Tables/PetNames.cpp

@@ -0,0 +1,26 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO `pet_names` (`id`, `pet_name`, `approved`) VALUES (?, ?, ?) "
+		"ON CONFLICT(id) DO UPDATE SET pet_name = ?, approved = ?;",
+		petId,
+		info.petName,
+		info.approvalStatus,
+		info.petName,
+		info.approvalStatus);
+}
+
+std::optional<IPetNames::Info> SQLiteDatabase::GetPetNameInfo(const LWOOBJID& petId) {
+	auto [_, result] = ExecuteSelect("SELECT pet_name, approved FROM pet_names WHERE id = ? LIMIT 1;", petId);
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	IPetNames::Info toReturn;
+	toReturn.petName = result.getStringField("pet_name");
+	toReturn.approvalStatus = result.getIntField("approved");
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/PlayKeys.cpp

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

dDatabase/GameDatabase/SQLite/Tables/PlayerCheatDetections.cpp

@@ -0,0 +1,7 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::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/SQLite/Tables/Property.cpp

@@ -0,0 +1,195 @@
+#include "SQLiteDatabase.h"
+#include "ePropertySortType.h"
+
+std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(const IProperty::PropertyLookup& params) {
+	std::optional<IProperty::PropertyEntranceResult> result;
+	std::string query;
+	std::pair<CppSQLite3Statement, CppSQLite3Query> propertiesRes;
+
+	if (params.sortChoice == SORT_TYPE_FEATURED || params.sortChoice == SORT_TYPE_FRIENDS) {
+		query = R"QUERY(
+		FROM properties as p
+		JOIN charinfo as ci
+		ON ci.prop_clone_id = p.clone_id
+		where p.zone_id = ?
+		AND (
+			p.description LIKE ?
+		    OR p.name LIKE ?
+		    OR ci.name LIKE ?
+		)
+		AND p.privacy_option >= ?
+		AND p.owner_id IN (
+			SELECT fr.requested_player AS player FROM (
+				SELECT CASE 
+				WHEN player_id = ? THEN friend_id 
+				WHEN friend_id = ? THEN player_id 
+				END AS requested_player 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 != ?
+		) ORDER BY ci.name ASC
+		)QUERY";
+		const auto completeQuery = "SELECT p.* " + query + " LIMIT ? OFFSET ?;";
+		propertiesRes = ExecuteSelect(
+			completeQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.playerId,
+			params.playerId,
+			params.playerId,
+			params.numResults,
+			params.startIndex
+		);
+		const auto countQuery = "SELECT COUNT(*) as count" + query + ";";
+		auto [_, count] = ExecuteSelect(
+			countQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.playerId,
+			params.playerId,
+			params.playerId
+		);
+		if (!count.eof()) {
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
+		}
+	} else {
+		if (params.sortChoice == SORT_TYPE_REPUTATION) {
+			query = R"QUERY(
+			FROM properties as p
+			JOIN charinfo as ci
+			ON ci.prop_clone_id = p.clone_id
+			where p.zone_id = ?
+			AND (
+				p.description LIKE ?
+			    OR p.name LIKE ?
+			    OR ci.name LIKE ?
+			)
+			AND p.privacy_option >= ?
+			ORDER BY p.reputation DESC, p.last_updated DESC 
+			)QUERY";
+		} else {
+			query = R"QUERY(
+			FROM properties as p
+			JOIN charinfo as ci
+			ON ci.prop_clone_id = p.clone_id
+			where p.zone_id = ?
+			AND (
+				p.description LIKE ?
+			    OR p.name LIKE ?
+			    OR ci.name LIKE ?
+			)
+			AND p.privacy_option >= ?
+			ORDER BY p.last_updated DESC
+			)QUERY";
+		}
+		const auto completeQuery = "SELECT p.* " + query + " LIMIT ? OFFSET ?;";
+		propertiesRes = ExecuteSelect(
+			completeQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.numResults,
+			params.startIndex
+		);
+		const auto countQuery = "SELECT COUNT(*) as count" + query + ";";
+		auto [_, count] = ExecuteSelect(
+			countQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort
+		);
+		if (!count.eof()) {
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
+		}
+	}
+
+	auto& [_, properties] = propertiesRes;
+	if (!properties.eof() && !result.has_value()) result = IProperty::PropertyEntranceResult();
+	while (!properties.eof()) {
+		auto& entry = result->entries.emplace_back();
+		entry.id = properties.getInt64Field("id");
+		entry.ownerId = properties.getInt64Field("owner_id");
+		entry.cloneId = properties.getInt64Field("clone_id");
+		entry.name = properties.getStringField("name");
+		entry.description = properties.getStringField("description");
+		entry.privacyOption = properties.getIntField("privacy_option");
+		entry.rejectionReason = properties.getStringField("rejection_reason");
+		entry.lastUpdatedTime = properties.getIntField("last_updated");
+		entry.claimedTime = properties.getIntField("time_claimed");
+		entry.reputation = properties.getIntField("reputation");
+		entry.modApproved = properties.getIntField("mod_approved");
+		entry.performanceCost = properties.getFloatField("performance_cost");
+		properties.nextRow();
+	}
+
+	return result;
+}
+
+std::optional<IProperty::Info> SQLiteDatabase::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, performance_cost "
+		"FROM properties WHERE zone_id = ? AND clone_id = ?;", mapId, cloneId);
+
+	if (propertyEntry.eof()) {
+		return std::nullopt;
+	}
+
+	IProperty::Info toReturn;
+	toReturn.id = propertyEntry.getInt64Field("id");
+	toReturn.ownerId = propertyEntry.getInt64Field("owner_id");
+	toReturn.cloneId = propertyEntry.getInt64Field("clone_id");
+	toReturn.name = propertyEntry.getStringField("name");
+	toReturn.description = propertyEntry.getStringField("description");
+	toReturn.privacyOption = propertyEntry.getIntField("privacy_option");
+	toReturn.rejectionReason = propertyEntry.getStringField("rejection_reason");
+	toReturn.lastUpdatedTime = propertyEntry.getIntField("last_updated");
+	toReturn.claimedTime = propertyEntry.getIntField("time_claimed");
+	toReturn.reputation = propertyEntry.getIntField("reputation");
+	toReturn.modApproved = propertyEntry.getIntField("mod_approved");
+	toReturn.performanceCost = propertyEntry.getFloatField("performance_cost");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET privacy_option = ?, rejection_reason = ?, mod_approved = ? WHERE id = ?;",
+		info.privacyOption,
+		info.rejectionReason,
+		info.modApproved,
+		info.id);
+}
+
+void SQLiteDatabase::UpdatePropertyDetails(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET name = ?, description = ? WHERE id = ?;", info.name, info.description, info.id);
+}
+
+void SQLiteDatabase::UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) {
+	ExecuteUpdate("UPDATE properties SET performance_cost = ? WHERE zone_id = ? AND clone_id = ?;", performanceCost, zoneId.GetMapID(), zoneId.GetCloneID());
+}
+
+void SQLiteDatabase::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, CAST(strftime('%s', 'now') as INT), CAST(strftime('%s', 'now') as INT), '', 0, 0.0)",
+		info.id,
+		info.ownerId,
+		templateId,
+		zoneId.GetCloneID(),
+		info.name,
+		info.description,
+		zoneId.GetMapID()
+	);
+}

dDatabase/GameDatabase/SQLite/Tables/PropertyContents.cpp

@@ -0,0 +1,65 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IPropertyContents::Model> SQLiteDatabase::GetPropertyModels(const LWOOBJID& propertyId) {
+	auto [_, result] = ExecuteSelect(
+		"SELECT id, lot, x, y, z, rx, ry, rz, rw, ugc_id, "
+		"behavior_1, behavior_2, behavior_3, behavior_4, behavior_5 "
+		"FROM properties_contents WHERE property_id = ?;", propertyId);
+
+	std::vector<IPropertyContents::Model> toReturn;
+	while (!result.eof()) {
+		IPropertyContents::Model model;
+		model.id = result.getInt64Field("id");
+		model.lot = static_cast<LOT>(result.getIntField("lot"));
+		model.position.x = result.getFloatField("x");
+		model.position.y = result.getFloatField("y");
+		model.position.z = result.getFloatField("z");
+		model.rotation.w = result.getFloatField("rw");
+		model.rotation.x = result.getFloatField("rx");
+		model.rotation.y = result.getFloatField("ry");
+		model.rotation.z = result.getFloatField("rz");
+		model.ugcId = result.getInt64Field("ugc_id");
+		model.behaviors[0] = result.getIntField("behavior_1");
+		model.behaviors[1] = result.getIntField("behavior_2");
+		model.behaviors[2] = result.getIntField("behavior_3");
+		model.behaviors[3] = result.getIntField("behavior_4");
+		model.behaviors[4] = result.getIntField("behavior_5");
+
+		toReturn.push_back(std::move(model));
+		result.nextRow();
+	}
+	return toReturn;
+}
+
+void SQLiteDatabase::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.
+			model.behaviors[0], // behavior 1
+			model.behaviors[1], // behavior 2
+			model.behaviors[2], // behavior 3
+			model.behaviors[3], // behavior 4
+			model.behaviors[4] // behavior 5
+		);
+	} catch (std::exception& e) {
+		LOG("Error inserting new property model: %s", e.what());
+	}
+}
+
+void SQLiteDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
+	ExecuteUpdate(
+		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
+		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
+		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w,
+		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, propertyId);
+}
+
+void SQLiteDatabase::RemoveModel(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
+}

dDatabase/GameDatabase/SQLite/Tables/Servers.cpp

@@ -0,0 +1,23 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::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("DELETE FROM servers;");
+	ExecuteInsert("INSERT INTO `servers` (`name`, `ip`, `port`, `state`, `version`) VALUES ('master', ?, ?, 0, 171022)", ip, port);
+}
+
+std::optional<IServers::MasterInfo> SQLiteDatabase::GetMasterInfo() {
+	auto [_, result] = ExecuteSelect("SELECT ip, port FROM servers WHERE name='master' LIMIT 1;");
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	MasterInfo toReturn;
+
+	toReturn.ip = result.getStringField("ip");
+	toReturn.port = result.getIntField("port");
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

@@ -0,0 +1,72 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IUgc::Model> SQLiteDatabase::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.eof()) {
+		IUgc::Model model;
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		model.id = result.getInt64Field("id");
+		toReturn.push_back(std::move(model));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::vector<IUgc::Model> SQLiteDatabase::GetAllUgcModels() {
+	auto [_, result] = ExecuteSelect("SELECT id, lxfml FROM ugc;");
+
+	std::vector<IUgc::Model> models;
+	while (!result.eof()) {
+		IUgc::Model model;
+		model.id = result.getInt64Field("id");
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		models.push_back(std::move(model));
+		result.nextRow();
+	}
+
+	return models;
+}
+
+void SQLiteDatabase::RemoveUnreferencedUgcModels() {
+	ExecuteDelete("DELETE FROM ugc WHERE id NOT IN (SELECT ugc_id FROM properties_contents WHERE ugc_id IS NOT NULL);");
+}
+
+void SQLiteDatabase::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 SQLiteDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM ugc WHERE id = ?;", modelId);
+	ExecuteDelete("DELETE FROM properties_contents WHERE ugc_id = ?;", modelId);
+}
+
+void SQLiteDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
+	const std::istream stream(lxfml.rdbuf());
+	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
+}

dDatabase/GameDatabase/SQLite/Tables/UgcModularBuild.cpp

@@ -0,0 +1,9 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) {
+	ExecuteInsert("INSERT INTO ugc_modular_build (ugc_id, ldf_config, character_id) VALUES (?,?,?)", bigId, modules, characterId);
+}
+
+void SQLiteDatabase::DeleteUgcBuild(const LWOOBJID bigId) {
+	ExecuteDelete("DELETE FROM ugc_modular_build WHERE ugc_id = ?;", bigId);
+}

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -8,10 +8,6 @@ void TestSQLDatabase::Destroy(std::string source) {
 
 }
 
-sql::PreparedStatement* TestSQLDatabase::CreatePreppedStmt(const std::string& query) {
-	return nullptr;
-}
-
 void TestSQLDatabase::Commit() {
 
 }

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -7,7 +7,6 @@ class TestSQLDatabase : public GameDatabase {
 	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;
@@ -102,6 +101,7 @@ class TestSQLDatabase : public GameDatabase {
 	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override {};
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
+	uint32_t GetAccountCount() override { return 0; };
 };
 
 #endif  //!TESTSQLDATABASE_H