SQLStatement.hpp

#pragma once
#include <samchon/API.hpp>

#include <vector>
#include <memory>
#include <samchon/Map.hpp>
#include <string>
#include <samchon/ByteArray.hpp>

namespace samchon
{
namespace library
{
    class SQLi;
    class XML;
        
    class SAMCHON_FRAMEWORK_API SQLStatement
    {
        friend class SQLi;
    private:
#ifdef _WIN64
        typedef long long SQL_SIZE_T;
#else
        typedef long SQL_SIZE_T;
#endif

    protected:
        /* --------------------------------------------------------------
            BASIC MEMBER VARIABLES
        -------------------------------------------------------------- */
        SQLi *sqli;

        void *hstmt;

        /* --------------------------------------------------------------
            MEMBER VARIABLES FOR BINDING
        -------------------------------------------------------------- */
        size_t bindParameterCount;

        Map<size_t, SQL_SIZE_T> bindParameterBASizeMap;

    protected:
        SQLStatement(SQLi *sqli);
        void reset(SQLi *sqli);

    public:
        virtual ~SQLStatement();

    public:
        void free();

        void refresh();

        /* -----------------------------------------------------------------------
            QUERY
        ----------------------------------------------------------------------- */
        template <typename T, typename ... _Args>
        void prepare(const std::string &sql, const T& val, const _Args& ... args)
        {
            prepare(sql);

            bindParameter(val);
            bindParameter(args...);
        };
        template <typename T> void prepare(const std::string &str, const T& val)
        {
            prepare(str);

            bindParameter(val);
        };
        void prepare(const std::string &);
        void prepare(const std::wstring &);

        template <typename T, typename ... _Args>
        void prepare(const std::wstring &sql, const T& val, const _Args& ... args)
        {
            prepare(sql);

            bindParameter(val);
            bindParameter(args...);
        };
        template <typename T> void prepare(const std::wstring &str, const T& val)
        {
            prepare(str);

            bindParameter(val);
        };

        void execute();

        void executeDirectly(const std::string&);
        void executeDirectly(const std::wstring&);

        /* -----------------------------------------------------------------------
            CURSOR
        ----------------------------------------------------------------------- */
        auto fetch() const -> bool;

        auto next() const -> bool;

        /* -------------------------------------------------------------------------
            GET DATA IN A COLUMN
        ------------------------------------------------------------------------- */
        auto size() const -> size_t;

        template <typename T> auto at(size_t index) const -> T
        {
            T val;
            sql_get_data(index + 1, C_TYPE(T()), &val);

            return val;
        };
        template<> auto at(size_t index) const -> std::string
        {
            return _atAsString(index);
        }
        template<> auto at(size_t index) const -> std::wstring
        {
            return _atAsWString(index);
        };
        template<> auto at(size_t index) const -> ByteArray
        {
            return _atAsByteArray(index);
        };

        template <typename T> auto get(const std::string &) const -> T
        {
            return this->at<T>(0);
        };

        virtual auto toXML() const->std::shared_ptr<XML>;

    private:
        /* -------------------------------------------------------------------
            BIND
        ------------------------------------------------------------------- */
        template <typename T, typename ... _Args>
        void bindParameter(const T& val, const _Args& ... args)
        {
            bindParameter(val);
            bindParameter(args...);
        };
        template <typename T> void bindParameter(const T &val)
        {
            sql_bind_parameter(C_TYPE(val), SQL_TYPE(val), (void*)&val);
        };
        template<> void bindParameter(const std::string &val);
        template<> void bindParameter(const std::wstring &val);
        template<> void bindParameter(const ByteArray &val);

        /* -------------------------------------------------------------------
            ODBC'S FUNCTION
        ------------------------------------------------------------------- */
        void sql_get_data(size_t, short, void*) const;
        void sql_bind_parameter(short, short, void*);

        template <typename T> auto C_TYPE(const T &) const -> short;
        template<> auto C_TYPE(const bool &) const -> short;
        template<> auto C_TYPE(const char &) const -> short;
        template<> auto C_TYPE(const short &) const -> short;
        template<> auto C_TYPE(const long &) const -> short;
        template<> auto C_TYPE(const long long &) const -> short;
        template<> auto C_TYPE(const int &) const -> short;
        template<> auto C_TYPE(const float &) const -> short;
        template<> auto C_TYPE(const double &) const -> short;

        template<> auto C_TYPE(const unsigned char &) const -> short;
        template<> auto C_TYPE(const unsigned short &) const -> short;
        template<> auto C_TYPE(const unsigned long &) const -> short;
        template<> auto C_TYPE(const unsigned long long &) const -> short;
        template<> auto C_TYPE(const unsigned int &) const -> short;
        template<> auto C_TYPE(const long double &) const -> short;

        template<> auto C_TYPE(const std::string &) const -> short;
        template<> auto C_TYPE(const std::wstring &) const -> short;
        template<> auto C_TYPE(const ByteArray &) const -> short;

        template <typename T> auto SQL_TYPE(const T &) const -> short;
        template<> auto SQL_TYPE(const bool &) const -> short;
        template<> auto SQL_TYPE(const char &) const -> short;
        template<> auto SQL_TYPE(const short &) const -> short;
        template<> auto SQL_TYPE(const long &) const -> short;
        template<> auto SQL_TYPE(const long long &) const -> short;
        template<> auto SQL_TYPE(const int &) const -> short;
        template<> auto SQL_TYPE(const float &) const -> short;
        template<> auto SQL_TYPE(const double &) const -> short;

        template<> auto SQL_TYPE(const unsigned char &) const -> short;
        template<> auto SQL_TYPE(const unsigned short &) const -> short;
        template<> auto SQL_TYPE(const unsigned long &) const -> short;
        template<> auto SQL_TYPE(const unsigned long long &) const -> short;
        template<> auto SQL_TYPE(const unsigned int &) const -> short;
        template<> auto SQL_TYPE(const long double &) const -> short;

        template<> auto SQL_TYPE(const std::string &) const -> short;
        template<> auto SQL_TYPE(const std::wstring &) const -> short;
        template<> auto SQL_TYPE(const ByteArray &) const -> short;

    private:
        /* -------------------------------------------------------------------
            HIDDEN TEMPLATE HELPERS
        ------------------------------------------------------------------- */
        auto _atAsString(size_t index) const -> std::string;
        auto _atAsWString(size_t index) const -> std::wstring;

        auto _atAsByteArray(size_t index) const -> ByteArray;
    };
};
};