prepared_stmt.hxx

#pragma once
 
#include <StormByte/database/rows.hxx>
 
namespace StormByte::Database {
    class STORMBYTE_DATABASE_PUBLIC PreparedSTMT {
        public:
            PreparedSTMT(const std::string& name, const std::string& query) noexcept:
            m_name(name), m_query(query) {}
 
            PreparedSTMT(std::string&& name, std::string&& query) noexcept:
            m_name(std::move(name)), m_query(std::move(query)) {}
 
            PreparedSTMT(const PreparedSTMT& other)                         = delete;
 
            PreparedSTMT(PreparedSTMT&& other)                              = default;
 
            virtual ~PreparedSTMT()                                         = default;
 
            PreparedSTMT& operator=(const PreparedSTMT& other)              = delete;
 
            PreparedSTMT& operator=(PreparedSTMT&& other)                   = default;
 
            template<typename... Args>
            ExpectedRows                                                    Execute(Args&&... args) {
                Reset();
                // Bind implementations expect a zero-based index and add +1 internally
                std::size_t idx = 0;
                (void)( ( Bind(static_cast<int>(idx++), std::forward<Args>(args)) ), ... );
                ExpectedRows result = DoExecute();
                Reset();
                return result;
            }
 
            inline const std::string&                                       Name() const noexcept {
                return m_name;
            }
 
            inline const std::string&                                       Query() const noexcept {
                return m_query;
            }
 
        protected:
            std::string m_name;                                             
            std::string m_query;                                            
 
        private:
            virtual void                                                    Bind(const int& index, const std::nullptr_t& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const int& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const unsigned int& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const int64_t& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const uint64_t& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const double& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, bool value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const std::string& value) noexcept = 0;
 
            virtual void                                                    Bind(const int& index, const std::vector<std::byte>& value) noexcept = 0;
 
            inline void                                                     Bind(const int& index, const char* value) noexcept {
                Bind(index, std::string(value));
            }
 
            virtual void                                                    Reset() noexcept = 0;
 
            virtual ExpectedRows                                            DoExecute() = 0;
    };
}