mostlyharmless_DatabaseState.h

Go to the documentation of this file.

//
// Created by Syl Morrison on 09/04/2025.
//
 
#ifndef MOSTLYHARMLESS_DATABASESTATE_H
#define MOSTLYHARMLESS_DATABASESTATE_H
 
#include <mostly_harmless/mostlyharmless_Concepts.h>
#include <mostly_harmless/utils/mostlyharmless_Macros.h>
#include <sqlite3.h>
#include <fmt/core.h>
#include <string>
#include <filesystem>
#include <variant>
 
namespace mostly_harmless::data {

    namespace {
        enum Index : size_t {
            TextIndex = 1,
            BoolIndex = 2,
            IntIndex = 3,
            FloatIndex = 4,
            DoubleIndex = 5
        };
 
        template <DatabaseStorageType T>
        auto databaseQueryCallback(void* ud, int count, char** data, char** /*columns*/) -> int {
            auto* result = static_cast<std::optional<T>*>(ud);
            if (count != 6) {
                return SQLITE_FAIL;
            }
            if constexpr (std::same_as<T, std::string>) {
                *result = data[Index::TextIndex];
            } else if constexpr (std::same_as<T, bool>) {
                *result = static_cast<T>(std::stoi(data[Index::BoolIndex]));
            } else if constexpr (std::is_integral_v<T>) {
                *result = static_cast<T>(std::stoi(data[Index::IntIndex]));
            } else if constexpr (std::same_as<T, float>) {
                *result = std::stof(data[Index::FloatIndex]);
            } else if constexpr (std::same_as<T, double>) {
                *result = std::stod(data[Index::DoubleIndex]);
            }
            return SQLITE_OK;
        }
    } // namespace

    using DatabaseValueVariant = std::variant<std::string, bool, int, float, double>;
    class DatabaseState final {
    private:
        struct Private {};
 
    public:
        DatabaseState(Private, const std::filesystem::path& location, const std::vector<std::pair<std::string, DatabaseValueVariant>>& initialValues) {
            const auto checkResult = [](int response) -> void {
                if (response != SQLITE_OK) {
                    throw std::exception{};
                }
            };
 
            if (!std::filesystem::exists(location.parent_path()) && location.string() != ":memory:") {
                throw std::exception{};
            }
            // Try open existing
            if (sqlite3_open_v2(location.string().c_str(), &m_databaseHandle, SQLITE_OPEN_READWRITE, nullptr) != SQLITE_OK) {
                checkResult(sqlite3_open(location.string().c_str(), &m_databaseHandle)); // Didn't exist, try create
            }
            // Enable WAL
            checkResult(sqlite3_exec(m_databaseHandle, "PRAGMA journal_mode=WAL", nullptr, nullptr, nullptr));
            // Create Table if not present
            checkResult(sqlite3_exec(m_databaseHandle,
                                     "CREATE TABLE IF NOT EXISTS DATA (NAME text UNIQUE, TEXT_VALUE text, BOOL_VALUE bool, INT_VALUE int, FLOAT_VALUE float, DOUBLE_VALUE double);",
                                     nullptr,
                                     nullptr,
                                     nullptr));
            // Populate with initial values, if key is present already, skip set
            for (const auto& [key, value] : initialValues) {
                std::visit([this, &key](auto&& arg) {
                    using T = std::decay_t<decltype(arg)>;
                    if (get<T>(key)) {
                        return;
                    }
                    set(key, std::forward<decltype(arg)>(arg));
                },
                           value);
            }
        }

        DatabaseState(const DatabaseState& /*other*/) = delete;

        DatabaseState(DatabaseState&& other) noexcept {
            std::swap(m_databaseHandle, other.m_databaseHandle);
        }

        DatabaseState& operator=(const DatabaseState& /*other*/) = delete;

        DatabaseState& operator=(DatabaseState&& other) noexcept {
            if (this != &other) {
                std::swap(m_databaseHandle, other.m_databaseHandle);
            }
            return *this;
        }

        [[nodiscard]] static auto tryCreate(const std::filesystem::path& location, const std::vector<std::pair<std::string, DatabaseValueVariant>>& initialValues) -> std::optional<DatabaseState> {
            try {
                DatabaseState state{ {}, location, initialValues };
                return std::move(state);
            } catch (...) {
                assert(false);
                return {};
            }
        }

        ~DatabaseState() noexcept {
            if (!m_databaseHandle) return;
            sqlite3_close(m_databaseHandle);
        }

        template <DatabaseStorageType T>
        auto set(std::string_view name, const T& toSet) -> void {
            struct {
                std::string textValue{};
                bool boolValue{ false };
                int intValue{ 0 };
                float floatValue{ 0.0f };
                double doubleValue{ 0.0 };
            } props;
 
            std::string updateStr;
            if constexpr (std::same_as<T, std::string>) {
                props.textValue = toSet;
                updateStr = fmt::format("TEXT_VALUE = \"{}\"", props.textValue);
            } else if constexpr (std::same_as<T, bool>) {
                props.boolValue = toSet;
                updateStr = fmt::format("BOOL_VALUE = {}", props.boolValue);
            } else if constexpr (std::is_integral_v<T>) {
                props.intValue = static_cast<int>(toSet);
                updateStr = fmt::format("INT_VALUE = {}", props.intValue);
            } else if constexpr (std::same_as<T, float>) {
                props.floatValue = toSet;
                updateStr = fmt::format("FLOAT_VALUE = {}", props.floatValue);
            } else if constexpr (std::same_as<T, double>) {
                props.doubleValue = toSet;
                updateStr = fmt::format("DOUBLE_VALUE = {}", props.doubleValue);
            }
 
            std::stringstream sstream;
            sstream << "INSERT INTO DATA (NAME, TEXT_VALUE, BOOL_VALUE, INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE)\n";
            sstream << "    VALUES ( \"" << name << "\", \"" << props.textValue << "\", " << props.boolValue << "," << props.intValue << ", " << props.floatValue << ", " << props.doubleValue << " )\n";
            sstream << "    ON CONFLICT(NAME) DO UPDATE SET " << updateStr << ";";
            const auto execResult = sqlite3_exec(m_databaseHandle, sstream.str().c_str(), nullptr, nullptr, nullptr);
            if (execResult != SQLITE_OK) {
                MH_LOG(sqlite3_errmsg(m_databaseHandle));
                assert(false);
            }
        }

        template <DatabaseStorageType T>
        [[nodiscard]] auto get(std::string_view name) -> std::optional<T> {
            std::optional<T> result{};
            const auto execStr = fmt::format("SELECT * FROM DATA WHERE NAME = \"{}\"", name);
            const auto getRes = sqlite3_exec(m_databaseHandle,
                                             execStr.c_str(),
                                             databaseQueryCallback<T>,
                                             static_cast<void*>(&result),
                                             nullptr);
            if (getRes != SQLITE_OK) {
                MH_LOG(sqlite3_errmsg(m_databaseHandle));
                assert(false);
            }
            return result;
        }

        [[nodiscard]] auto duplicate() const -> std::optional<DatabaseState> {
            const auto filenameOpt = getDatabaseFilename();
            if (!filenameOpt) {
                return {};
            }
            const std::filesystem::path databasePath{ *filenameOpt };
            if (!std::filesystem::exists(databasePath)) {
                return {};
            }
            return tryCreate(databasePath, {});
        }
 
    private:
        [[nodiscard]] auto getDatabaseFilename() const noexcept -> std::optional<std::string> {
            const auto* res = sqlite3_db_filename(m_databaseHandle, "main");
            if (!res || strcmp(res, "") == 0) {
                return {};
            }
            return std::string{ res };
        }
        sqlite3* m_databaseHandle{ nullptr };
    };
 
 
} // namespace mostly_harmless::data
 
#endif // MOSTLYHARMLESS_DATABASESTATE_H