database.hxx

#pragma once
 
#include <StormByte/database/visibility.h>
 
#include <map>
#include <memory>
#include <string>
 
namespace StormByte::Database {
    template<class Query, class PreparedSTMT> class STORMBYTE_DATABASE_PUBLIC Database {
        public:
            Database()                                          = default;
 
            Database(const Database&)                           = delete;
 
            Database(Database&&)                                = default;
 
            Database& operator=(const Database&)                = delete;
 
            Database& operator=(Database&&)                     = default;
 
            virtual ~Database()                                 = default;
 
            virtual void                                        Connect()       = 0;
 
            virtual void                                        Disconnect()    = 0;
 
            std::unique_ptr<Query>                              PrepareQuery(const std::string& query) {
                return InternalQuery(query);
            }
 
            void                                                SilentQuery(const std::string& query) {
                InternalQuery(query)->Step();
            }
 
            void                                                PrepareSTMT(const std::string& name, const std::string& query) {
                m_prepared_stmts.insert({name, InternalPrepare(name, query)});
            }
 
            void                                                PrepareAll(const std::map<std::string, std::string>& queries) {
                for (const auto& [name, query]: queries) {
                    PrepareSTMT(name, query);
                }
            }
 
            PreparedSTMT&                                       GetPreparedSTMT(const std::string& name) const {
                return *m_prepared_stmts.at(name);
            }
 
            virtual void                                        BeginTransaction() {
                SilentQuery("BEGIN TRANSACTION;");
            }
 
            virtual void                                        BeginExclusiveTransaction() {
                SilentQuery("BEGIN EXCLUSIVE TRANSACTION;");
            }
 
            virtual void                                        CommitTransaction() {
                SilentQuery("COMMIT;");
            }
 
            virtual void                                        RollbackTransaction() {
                SilentQuery("ROLLBACK;");
            }
 
            virtual const std::string                           LastError() const = 0;
 
        protected:
            std::map<std::string, std::unique_ptr<PreparedSTMT>> m_prepared_stmts;  
 
            virtual std::unique_ptr<PreparedSTMT>               InternalPrepare(const std::string& name, const std::string& query) = 0;
 
            virtual std::unique_ptr<Query>                      InternalQuery(const std::string& query) = 0;
    };
}