database.hxx

#pragma once
 
#include <StormByte/database/prepared_stmt.hxx>
#include <StormByte/database/rows.hxx>
#include <StormByte/logger/log.hxx>
 
#include <unordered_map>
 
namespace StormByte::Database {
    class STORMBYTE_DATABASE_PUBLIC Database {
        public:
            Database(std::shared_ptr<Logger::Log> logger) noexcept:
            m_logger(logger), m_connected(false) {};
 
            Database(const Database& other)                             = delete;
 
            Database(Database&& other)                                  = default;
 
            Database& operator=(const Database& other)                  = delete;
 
            Database& operator=(Database&& other)                       = default;
 
            virtual ~Database()                                         = default;
 
            bool                                                        Connect() noexcept;
 
            virtual void                                                Disconnect() noexcept;
 
            inline bool                                                 IsConnected() const noexcept {
                return m_connected;
            }
 
            template<typename... Args>
            inline ExpectedRows                                         ExecuteSTMT(const std::string& name, Args&&... args) {
                auto it = m_prepared_stmts.find(name);
                if (it == m_prepared_stmts.end())
                    return Unexpected<UnknownSTMT>(name);
                return it->second->Execute(std::forward<Args>(args)...);
            }
 
            virtual ExpectedRows                                        Query(const std::string& query) = 0;
 
            virtual bool                                                SilentQuery(const std::string& query) noexcept = 0;
 
            inline virtual void                                         BeginTransaction() {
                SilentQuery("BEGIN TRANSACTION;");
            }
 
            inline virtual void                                         BeginExclusiveTransaction() {
                SilentQuery("BEGIN EXCLUSIVE TRANSACTION;");
            }
 
            inline virtual void                                         CommitTransaction() {
                SilentQuery("COMMIT;");
            }
 
            inline virtual void                                         RollbackTransaction() {
                SilentQuery("ROLLBACK;");
            }
 
        protected:
            std::shared_ptr<Logger::Log> m_logger;                      
            std::unordered_map<
                std::string,
                std::unique_ptr<PreparedSTMT>
            > m_prepared_stmts;                                         
            bool m_connected;                                           
 
            virtual void                                                DoPreConnect() noexcept {}
 
            virtual bool                                                DoConnect() noexcept = 0;
 
            virtual void                                                DoPostConnect() noexcept {}
 
            virtual void                                                DoPreDisconnect() noexcept {}
 
            virtual void                                                DoDisconnect() noexcept = 0;
 
            virtual void                                                DoPostDisconnect() noexcept {}
 
            virtual std::unique_ptr<PreparedSTMT>                       CreatePreparedSTMT(std::string&& name, std::string&& query) noexcept = 0;
 
            void                                                        PrepareSTMT(std::string&& name, std::string&& query) noexcept;
    };
}