SQLi.hpp

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

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

#include <samchon/library/SQLStatement.hpp>

#include <memory>
#include <samchon/library/StringUtil.hpp>

namespace samchon
{
namespace library
{
    class SQLi : public base::SQLiBase
    {
        friend class SQLStatement;

    protected:
        std::string driver;

        int port;

        bool connected;

    public:
        SQLi(const std::string &driver, int port)
        {
            stmt = nullptr;
            connected = false;

            this->driver = driver;
            this->port = port;
        };

        virtual ~SQLi()
        {
            disconnect();
        };

        virtual auto createStatement() -> std::shared_ptr<SQLStatement>
        {
            return std::shared_ptr<SQLStatement>(new SQLStatement(this));
        };

        virtual void connect
            (
                const std::string &ip, const std::string &db,
                const std::string &id, const std::string &pwd
            )
        {
            std::unique_lock<std::mutex> uk(stmtMutex);
            SQLRETURN res;
            SQLHANDLE environment;

            if ((res = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &environment)) == SQL_SUCCESS)
                if ((res = SQLSetEnvAttr(environment, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0)) == SQL_SUCCESS)
                    if ((res = SQLAllocHandle(SQL_HANDLE_DBC, environment, &hdbc)) == SQL_SUCCESS)
                    {
                        SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)3, NULL);

                        res = SQLDriverConnectA
                            (
                                hdbc, NULL,
                                (SQLCHAR*)&StringUtil::substitute
                                (
                                    "DRIVER={0};SERVER={1}, {2};DATABASE={3};UID={4};PWD={5};",
                                    driver, ip, port, db, id, pwd
                                )[0],
                                SQL_NTS, NULL, 1024, NULL, SQL_DRIVER_NOPROMPT
                            );
                    }

            SQLFreeHandle(SQL_HANDLE_DBC, environment);

            if (res != SQL_SUCCESS && res != SQL_SUCCESS_WITH_INFO)
            {
                disconnect();
                throw std::exception(getErrorMessage(SQL_HANDLE_DBC).c_str());
            }
            else
                connected = true;
        };

        virtual void disconnect()
        {
            //FOR STATIC DESTRUCTION
            std::unique_lock<std::mutex> uk(stmtMutex);
            
            SQLDisconnect(hdbc);
            SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
            connected = false;

            stmtMutex.unlock();
        };

        auto isConnected() const -> bool
        {
            if (connected == false)
                return false;

            unsigned int ret = SQL_CD_FALSE;
            SQLGetConnectAttr(hdbc, SQL_COPT_SS_CONNECTION_DEAD, &ret, SQL_IS_UINTEGER, NULL);

            return ret != SQL_CD_TRUE;
        };

    protected:
        virtual auto getErrorMessage(short type) const -> std::string
        {
            char state[1024];
            char message[1024];

            if (SQLGetDiagRecA(type, hdbc, 1, (SQLCHAR *)state, NULL, (SQLCHAR *)message, 1024, NULL) == SQL_SUCCESS)
                return message;
            else
                return "Unknown";
        };
    };
};
};