SQLStatement.hpp

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

#include <samchon/library/base/SQLiBase.hpp>

#include <vector>
#include <memory>
#include <string>

#include <samchon/ByteArray.hpp>
#include <samchon/HashMap.hpp>
#include <samchon/library/XML.hpp>

namespace samchon
{
namespace library
{
    class SQLi;
        
    class 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;

        HashMap<size_t, SQL_SIZE_T> bindParameterBASizeMap;

    protected:
        SQLStatement(SQLi *sqli)
        {
            this->sqli = sqli;
            bindParameterCount = 0;

            SQLAllocHandle(SQL_HANDLE_STMT, ((base::SQLiBase*)sqli)->hdbc, &hstmt);
        };

    public:
        virtual ~SQLStatement()
        {
            free();
        };

    public:
        void reset(SQLi *sqli)
        {
            free();
            this->sqli = sqli;

            SQLAllocHandle(SQL_HANDLE_STMT, ((base::SQLiBase*)sqli)->hdbc, &hstmt);
        };

        void free()
        {
            SQLFreeHandle(SQL_HANDLE_STMT, hstmt);

            bindParameterCount = 0;

            if (sqli == nullptr || ((base::SQLiBase*)sqli)->stmt != this)
                return;

            ((base::SQLiBase*)sqli)->stmt = nullptr;
            ((base::SQLiBase*)sqli)->stmtMutex.unlock();
        };

        void refresh()
        {
            reset(this->sqli);
        };

        /* -----------------------------------------------------------------------
            QUERY
        ----------------------------------------------------------------------- */
        void prepare(const std::string &sql)
        {
            refresh();

            ((base::SQLiBase*)sqli)->stmtMutex.lock();
            ((base::SQLiBase*)sqli)->stmt = this;

            SQLPrepareA(hstmt, (SQLCHAR*)&sql[0], SQL_NTS);
        };

        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::wstring &sql)
        {
            refresh();

            ((base::SQLiBase*)sqli)->stmtMutex.lock();
            ((base::SQLiBase*)sqli)->stmt = this;

            SQLPrepareW(hstmt, (SQLWCHAR*)&sql[0], SQL_NTS);
        };

        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()
        {
            SQLRETURN res = SQLExecute(hstmt);

            if (res == SQL_ERROR)
                throw std::exception(((base::SQLiBase*)sqli)->getErrorMessage(SQL_HANDLE_STMT).data());

            // device or resource busy
            // it means network disconnection in almost case
        };

        void executeDirectly(const std::string &sql)
        {
            prepare(sql);
            execute();
        };
        void executeDirectly(const std::wstring &sql)
        {
            prepare(sql);
            execute();
        };

        /* -----------------------------------------------------------------------
            CURSOR
        ----------------------------------------------------------------------- */
        auto fetch() const -> bool
        {
            do
            {
                SQLSMALLINT colSize = 0;
                SQLNumResultCols(hstmt, &colSize);

                if (colSize > 0)
                    break;
            } while (next() == true);

            return (SQLFetch(hstmt) == SQL_SUCCESS);
        };

        auto next() const -> bool
        {
            return (SQLMoreResults(hstmt) != SQL_NO_DATA);
        };

        /* -------------------------------------------------------------------------
            GET DATA IN A COLUMN
        ------------------------------------------------------------------------- */
        auto size() const -> size_t
        {
            SQLSMALLINT val = 0;

            SQLNumResultCols(hstmt, &val);
            return (size_t)val;
        };

        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
        {
            index++;

            std::string str(1, NULL);
            SQLLEN size = 0;

            if (::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_CHAR, &str[0], 0, &size) != SQL_SUCCESS && size != 0)
            {
                // IMPORTANT, FOR NULL-TERMINATED-STRING
                size++;

                str.assign(size, NULL);
                ::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_CHAR, &str[0], sizeof(char)*size, NULL);
            }

            // ERASE ZERO-CHARS
            return str.data();
        }
        template<> auto at(size_t index) const -> std::wstring
        {
            index++;

            std::wstring str(1, NULL);
            SQLLEN size = 0;

            if (::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_WCHAR, &str[0], 0, &size) != SQL_SUCCESS && size != 0)
            {
                // IMPORTANT, FOR NULL-TERMINATED-STRING
                size++;

                str.assign((size_t)size, NULL);
                ::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_WCHAR, &str[0], sizeof(wchar_t)*size, NULL);
            }

            // ERASE ZERO-CHARS
            return str.data();
        };
        template<> auto at(size_t index) const -> ByteArray
        {
            index++;

            ByteArray data;
            SQLLEN size = 0;

            if (::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_BINARY, &data[0], 0, &size) != SQL_SUCCESS && size != 0)
            {
                data.assign(size, NULL);
                ::SQLGetData(hstmt, (SQLUSMALLINT)index, SQL_C_BINARY, &data[0], data.size(), NULL);
            }
            return data;
        };

        /*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)
        {
            ::SQLBindParameter(hstmt, (SQLUSMALLINT)++bindParameterCount, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, val.size(), 0, (SQLPOINTER)val.data(), val.size(), NULL);
        };
        template<> void bindParameter(const std::wstring &val)
        {
            ::SQLBindParameter(hstmt, (SQLUSMALLINT)++bindParameterCount, SQL_PARAM_INPUT, SQL_C_WCHAR, SQL_WVARCHAR, val.size(), 0, (SQLPOINTER)val.data(), val.size(), NULL);
        };
        template<> void bindParameter(const ByteArray &val)
        {
            bindParameterBASizeMap.set(++bindParameterCount, (SQL_SIZE_T)val.size());

            ::SQLBindParameter(hstmt, (SQLUSMALLINT)bindParameterCount, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY, val.size(), 0, (unsigned char*)&val[0], 0, &bindParameterBASizeMap.get(bindParameterCount));
        };

        /* -------------------------------------------------------------------
            ODBC'S FUNCTION
        ------------------------------------------------------------------- */
        void sql_get_data(size_t index, short type, void *listener) const
        {
            ::SQLGetData(hstmt, (SQLUSMALLINT)index, type, listener, 0, nullptr);
        };
        void sql_bind_parameter(short cppType, short sqlType, void *val)
        {
            ::SQLBindParameter(hstmt, (SQLUSMALLINT)++bindParameterCount, SQL_PARAM_INPUT, cppType, sqlType, 0, 0, val, 0, nullptr);
        };

        template <typename T> auto C_TYPE(const T &) const -> short;
        template<> auto C_TYPE(const bool &) const -> short
        {
            return SQL_C_BIT;
        }
        template<> auto C_TYPE(const char &) const -> short
        {
            return SQL_CHAR;
        }
        template<> auto C_TYPE(const short &) const -> short
        {
            return SQL_C_SSHORT;
        }
        template<> auto C_TYPE(const long &) const -> short
        {
            return SQL_C_SLONG;
        }
        template<> auto C_TYPE(const long long &) const -> short
        {
            return SQL_C_SBIGINT;
        }
        template<> auto C_TYPE(const int &) const -> short
        {
            return SQL_C_SLONG;
        }
        template<> auto C_TYPE(const float &) const -> short
        {
            return SQL_C_FLOAT;
        }
        template<> auto C_TYPE(const double &) const -> short
        {
            return SQL_C_DOUBLE;
        }

        template<> auto C_TYPE(const unsigned char &) const -> short
        {
            return SQL_C_BINARY;
        }
        template<> auto C_TYPE(const unsigned short &) const -> short
        {
            return SQL_C_USHORT;
        }
        template<> auto C_TYPE(const unsigned long &) const -> short
        {
            return SQL_C_ULONG;
        }
        template<> auto C_TYPE(const unsigned long long &) const -> short
        {
            return SQL_C_UBIGINT;
        }
        template<> auto C_TYPE(const unsigned int &) const -> short
        {
            return SQL_C_UBIGINT;
        }
        template<> auto C_TYPE(const long double &) const -> short
        {
            return SQL_C_DOUBLE;
        }

        template<> auto C_TYPE(const std::string &) const -> short
        {
            return SQL_C_CHAR;
        }
        template<> auto C_TYPE(const std::wstring &) const -> short
        {
            return SQL_C_WCHAR;
        }
        template<> auto C_TYPE(const ByteArray &) const -> short
        {
            return SQL_C_BINARY;
        }

        template <typename T> auto SQL_TYPE(const T &) const -> short;
        template<> auto SQL_TYPE(const bool &) const -> short
        {
            return SQL_BIT;
        }
        template<> auto SQL_TYPE(const char &) const -> short
        {
            return SQL_CHAR;
        }
        template<> auto SQL_TYPE(const short &) const -> short
        {
            return SQL_TINYINT;
        }
        template<> auto SQL_TYPE(const long &) const -> short
        {
            return SQL_INTEGER;
        }
        template<> auto SQL_TYPE(const long long &) const -> short
        {
            return SQL_BIGINT;
        }
        template<> auto SQL_TYPE(const int &) const -> short
        {
            return SQL_INTEGER;
        }
        template<> auto SQL_TYPE(const float &) const -> short
        {
            return SQL_FLOAT;
        }
        template<> auto SQL_TYPE(const double &) const -> short
        {
            return SQL_DOUBLE;
        }

        template<> auto SQL_TYPE(const unsigned char &) const -> short
        {
            return SQL_BINARY;
        }
        template<> auto SQL_TYPE(const unsigned short &) const -> short
        {
            return SQL_TINYINT;
        }
        template<> auto SQL_TYPE(const unsigned long &) const -> short
        {
            return SQL_INTEGER;
        }
        template<> auto SQL_TYPE(const unsigned long long &) const -> short
        {
            return SQL_BIGINT;
        }
        template<> auto SQL_TYPE(const unsigned int &) const -> short
        {
            return SQL_INTEGER;
        }
        template<> auto SQL_TYPE(const long double &) const -> short
        {
            return SQL_DOUBLE;
        }

        template<> auto SQL_TYPE(const std::string &) const -> short
        {
            return SQL_CHAR;
        }
        template<> auto SQL_TYPE(const std::wstring &) const -> short
        {
            return SQL_WCHAR;
        }
        template<> auto SQL_TYPE(const ByteArray &) const -> short
        {
            return SQL_BINARY;
        }
    };
};
};