database.hpp

#pragma once
 
#include "database/BackendType.hpp"
#include "database/binding/Binding.hpp"
#include "database/CommandGeneratorFactory.hpp"
#include "query.hpp"
#include "soci/soci.h"
 
namespace orm
{
class Database
{
public:
    template <typename T>
    using Payload = db::binding::BindingPayload<T>;
 
    Database();
 
    auto connect(const std::string& connectionString) -> void;
 
    auto disconnect() -> void;
 
    template <typename T>
    auto select(Query<T>& query) -> std::vector<T>
    {
        std::vector<T> result;
 
        auto command = commandGeneratorFactory.getCommandGenerator(backendType).select(query.getData());
 
        Payload<T>::bindingInfo.joinedValues = query.getData().shouldJoin;
 
        soci::rowset<Payload<T>> preparedRowSet = (sql.prepare << command);
 
        for (auto& payload : preparedRowSet)
        {
            result.push_back(std::move(payload.value));
        }
 
        return result;
    }
 
    template <typename T>
    auto insert(const std::vector<T>& objects) -> void
    {
        for (const auto& object : objects)
        {
            insert(object);
        }
    }
 
    template <typename T>
    auto insert(T object) -> void
    {
        static auto command = commandGeneratorFactory.getCommandGenerator(backendType).insert(Model<T>::getModelInfo());
 
        const Payload<T> payload{};
 
        payload.value = std::move(object);
 
        sql << command, soci::use(payload);
    }
 
    template <typename T>
    auto createTable() -> void
    {
        static auto modelInfo = Model<T>::getModelInfo();
 
        static auto command = commandGeneratorFactory.getCommandGenerator(backendType).createTable(modelInfo);
 
        sql << command;
    }
 
    template <typename T>
    auto deleteTable() -> void
    {
        static Model<T> model;
 
        static auto command = commandGeneratorFactory.getCommandGenerator(backendType).dropTable(model.getModelInfo());
 
        sql << command;
    }
 
    auto getBackendType() -> db::BackendType;
 
    auto beginTransaction() -> void;
 
    auto commitTransaction() -> void;
 
    auto rollbackTransaction() -> void;
 
private:
    soci::session sql;
    std::unique_ptr<soci::transaction> transaction;
    db::BackendType backendType;
    db::CommandGeneratorFactory commandGeneratorFactory;
};
} // namespace orm