jnet::JNetDBConn 클래스 참조

DB Connection 추상화 더 자세히 ...

#include <JNetDB.h>

Public 멤버 함수
	JNetDBConn ()
	JNetDBConn (BOOL connectionErrorFileLogFlag)
	~JNetDBConn ()
bool	Connect (SQLHENV henv, const WCHAR *connectionString)
void	Clear ()
bool	Ping ()
bool	Execute (const WCHAR *query)
bool	Fetch ()
bool	GetSQLData (INT32 &data)
INT32	GetRowCount ()
void	Unbind ()
bool	BindParam (INT32 paramIndex, bool *value)
bool	BindParam (INT32 paramIndex, float *value)
bool	BindParam (INT32 paramIndex, double *value)
bool	BindParam (INT32 paramIndex, INT8 *value)
bool	BindParam (INT32 paramIndex, INT16 *value)
bool	BindParam (INT32 paramIndex, INT32 *value)
bool	BindParam (INT32 paramIndex, INT64 *value)
bool	BindParam (INT32 paramIndex, TIMESTAMP_STRUCT *value)
bool	BindParam (INT32 paramIndex, const WCHAR *str)
bool	BindParam (INT32 paramIndex, const BYTE *bin, INT32 size)
bool	BindCol (INT32 columnIndex, bool *value)
bool	BindCol (INT32 columnIndex, float *value)
bool	BindCol (INT32 columnIndex, double *value)
bool	BindCol (INT32 columnIndex, INT8 *value)
bool	BindCol (INT32 columnIndex, INT16 *value)
bool	BindCol (INT32 columnIndex, INT32 *value)
bool	BindCol (INT32 columnIndex, INT64 *value)
bool	BindCol (INT32 columnIndex, TIMESTAMP_STRUCT *value)
bool	BindCol (INT32 columnIndex, WCHAR *str, INT32 size, SQLLEN *index)
bool	BindCol (INT32 columnIndex, BYTE *bin, INT32 size, SQLLEN *index)
bool	BindParam (SQLUSMALLINT paramIndex, SQLSMALLINT cType, SQLSMALLINT sqlType, SQLULEN len, SQLPOINTER ptr, SQLLEN *index)
bool	BindCol (SQLUSMALLINT columnIndex, SQLSMALLINT cType, SQLULEN len, SQLPOINTER value, SQLLEN *index)

Private 멤버 함수
void	HandleError (SQLRETURN ret, SQLSMALLINT errMsgBuffLen=0, SQLWCHAR *errMsgOut=NULL, SQLSMALLINT *errMsgLenOut=NULL)
void	HandleError (SQLRETURN ret, SQLSMALLINT hType, SQLHANDLE handle, SQLSMALLINT errMsgBuffLen=0, SQLWCHAR *errMsgOut=NULL, SQLSMALLINT *errMsgLenOut=NULL)
void	ErrorMsgFileLogging (const SQLWCHAR *errMsg, SQLSMALLINT errMsgLen, const std::wstring &filePath)

Private 속성
SQLHDBC	m_DBConnection = SQL_NULL_HANDLE
SQLHSTMT	m_Statement = SQL_NULL_HANDLE
bool	m_ConnectionErrorFileLogFlag
const wchar_t *	m_ConnectionErrLogFile = L"ConnectionErrLog.txt"

정적 Private 속성
static std::mutex	m_LogFileMtx

상세한 설명

DB Connection 추상화

생성자 & 소멸자 문서화

JNetDBConn() [1/2]

jnet::JNetDBConn::JNetDBConn ( )

inline

: JNetDBConn(false) {}

JNetDBConn() [2/2]

jnet::JNetDBConn::JNetDBConn ( BOOL connectionErrorFileLogFlag )

inline

: m_ConnectionErrorFileLogFlag(connectionErrorFileLogFlag) {}

~JNetDBConn()

jnet::JNetDBConn::~JNetDBConn ( )

inline

                      {
            Clear();
        }

멤버 함수 문서화

Connect()

bool JNetDBConn::Connect	(	SQLHENV	henv,
		const WCHAR *	connectionString )

{
    SQLRETURN ret;
 
    // 1. 전달받은 SQL 환경 핸들을 바탕으로 실제 커넥션 핸들을 할당받는다.
    if (::SQLAllocHandle(SQL_HANDLE_DBC, henv, &m_DBConnection) != SQL_SUCCESS)
        return false;
 
    // 2. 커넥션 문자열을 바탕으로 실질적인 DB 연결 수행
    WCHAR stringBuffer[MAX_PATH] = { 0 };
    ::wcscpy_s(stringBuffer, connectionString);
 
    WCHAR resultString[MAX_PATH] = { 0 };
    SQLSMALLINT resultStringLen = 0;
 
    ret = ::SQLDriverConnectW(  // WCHAR 문자열 전용 연결 함수 호출
        m_DBConnection,
        NULL,
        reinterpret_cast<SQLWCHAR*>(stringBuffer),
        _countof(stringBuffer),
        OUT reinterpret_cast<SQLWCHAR*>(resultString),  // 결과 메시지 저장
        _countof(resultString),
        OUT & resultStringLen,
        SQL_DRIVER_NOPROMPT
    );
 
    if (!(ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)) {
        if (m_ConnectionErrorFileLogFlag) {
            SQLWCHAR    errMsgOut[WVARCHAR_MAX] = { NULL };
            SQLSMALLINT errMsgLen = 0;
            HandleError(ret, SQL_HANDLE_DBC, m_DBConnection, sizeof(errMsgOut), errMsgOut, &errMsgLen);
            ErrorMsgFileLogging(errMsgOut, errMsgLen, m_ConnectionErrLogFile);
        }
        else {
            HandleError(ret, SQL_HANDLE_DBC, m_DBConnection);
        }
 
 
 
        return false;
    }
 
    // 3. statement 핸들을 할당 받는다.
    if ((ret = ::SQLAllocHandle(SQL_HANDLE_STMT, m_DBConnection, &m_Statement)) != SQL_SUCCESS) {
        if (m_ConnectionErrorFileLogFlag) {
            SQLWCHAR    errMsgOut[WVARCHAR_MAX] = { NULL };
            SQLSMALLINT errMsgLen = 0;
            HandleError(ret, sizeof(errMsgOut), (SQLWCHAR*)errMsgOut, &errMsgLen);
            ErrorMsgFileLogging(errMsgOut, errMsgLen, m_ConnectionErrLogFile);
        }
        else {
            HandleError(ret);
        }
        return false;
    }
 
    return (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO);
}

Clear()

void JNetDBConn::Clear

(

)

{
    // 할당받은 핸들 정리
 
    if (m_DBConnection != SQL_NULL_HANDLE)
    {
        ::SQLFreeHandle(SQL_HANDLE_DBC, m_DBConnection);
        m_DBConnection = SQL_NULL_HANDLE;
    }
 
    if (m_Statement != SQL_NULL_HANDLE)
    {
        ::SQLFreeHandle(SQL_HANDLE_STMT, m_Statement);
        m_Statement = SQL_NULL_HANDLE;
    }
}

Ping()

bool JNetDBConn::Ping

(

)

{
    const SQLWCHAR* pingQuery = L"SELECT 1";
    return Execute(pingQuery);
}

Execute()

bool JNetDBConn::Execute

(

const WCHAR *

query

)

{
    // SQL 쿼리를 인자로 받아, SQLExecDirect 함수에 전달
    SQLRETURN ret = ::SQLExecDirectW(m_Statement, (SQLWCHAR*)query, SQL_NTSL);
    if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
        return true;
    }
 
    if (m_ConnectionErrorFileLogFlag) {
        SQLWCHAR    errMsgOut[WVARCHAR_MAX];
        SQLSMALLINT errMsgLen = 0;
        HandleError(ret, sizeof(errMsgOut), (SQLWCHAR*)errMsgOut, &errMsgLen);
        ErrorMsgFileLogging(errMsgOut, errMsgLen, m_ConnectionErrLogFile);
    }
    else {
        HandleError(ret);
    }
 
    return false;
}

Fetch()

bool JNetDBConn::Fetch

(

)

{
    // SQLFetch가 성공 반환 시, 수신 받을 데이터가 존재
    SQLRETURN ret = ::SQLFetch(m_Statement);
 
    switch (ret)
    {
    case SQL_SUCCESS:
    case SQL_SUCCESS_WITH_INFO:
        return true;
    case SQL_NO_DATA:       // 쿼리는 성공이나 반환 데이터가 없는 경우
        return false;
    case SQL_ERROR:         // 쿼리 수행 자체에서 문제 발생
    {
        if (m_ConnectionErrorFileLogFlag) {
            SQLWCHAR    errMsgOut[WVARCHAR_MAX];
            SQLSMALLINT errMsgLen = 0;
            HandleError(ret, sizeof(errMsgOut), (SQLWCHAR*)errMsgOut, &errMsgLen);
            ErrorMsgFileLogging(errMsgOut, errMsgLen, m_ConnectionErrLogFile);
        }
        else {
            HandleError(ret);
        }
    }
    return false;
    default:
        return true;
    }
}

GetSQLData()

bool JNetDBConn::GetSQLData

(

INT32 &

data

)

{
    SQLLEN indicator;
    SQLINTEGER count;
    SQLRETURN ret = SQLGetData(m_Statement, 1, SQL_C_SLONG, &count, sizeof(count), &indicator);
    if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
        data = count;
        return true;
    }
 
    return false;
}

GetRowCount()

INT32 JNetDBConn::GetRowCount

(

)

{
    SQLLEN count = 0;
    SQLRETURN ret = ::SQLRowCount(m_Statement, OUT & count);
 
    if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
        return static_cast<INT32>(count);
 
    return -1;
}

Unbind()

void JNetDBConn::Unbind

(

)

{
    ::SQLFreeStmt(m_Statement, SQL_UNBIND);
    ::SQLFreeStmt(m_Statement, SQL_RESET_PARAMS);
    ::SQLFreeStmt(m_Statement, SQL_CLOSE);
}

BindParam() [1/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		bool *	value )

                                                        {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_TINYINT, SQL_TINYINT, sizeof(bool), value, &index);
}

BindParam() [2/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		float *	value )

                                                         {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_FLOAT, SQL_FLOAT, 0, value, &index); // 일반 정수가 아닌 경우 'len'은 0
}

BindParam() [3/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		double *	value )

                                                          {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_DOUBLE, SQL_DOUBLE, 0, value, &index);
}

BindParam() [4/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		INT8 *	value )

                                                        {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_TINYINT, SQL_TINYINT, sizeof(INT8), value, &index);
}

BindParam() [5/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		INT16 *	value )

                                                         {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_SHORT, SQL_SMALLINT, sizeof(INT16), value, &index);
}

BindParam() [6/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		INT32 *	value )

                                                         {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_LONG, SQL_INTEGER, sizeof(INT32), value, &index);
}

BindParam() [7/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		INT64 *	value )

                                                         {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_SBIGINT, SQL_BIGINT, sizeof(INT64), value, &index);
}

BindParam() [8/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		TIMESTAMP_STRUCT *	value )

                                                                    {
    SQLLEN index = 0;
    return BindParam(paramIndex, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, sizeof(TIMESTAMP_STRUCT), value, &index);
}

BindParam() [9/11]

bool jnet::JNetDBConn::BindParam	(	INT32	paramIndex,
		const WCHAR *	str )

BindParam() [10/11]

bool JNetDBConn::BindParam	(	INT32	paramIndex,
		const BYTE *	bin,
		INT32	size )

                                                                        {
    SQLLEN index;
    if (bin == nullptr)
    {
        index = SQL_NULL_DATA;
        size = 1;
    }
    else {
        index = size;
    }
 
    if (size > BINARY_MAX)
        return BindParam(paramIndex, SQL_C_BINARY, SQL_LONGVARBINARY, size, (BYTE*)bin, &index);
    else
        return BindParam(paramIndex, SQL_C_BINARY, SQL_BINARY, size, (BYTE*)bin, &index);
}

BindCol() [1/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		bool *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_TINYINT, sizeof(bool), value, &index);
}

BindCol() [2/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		float *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_FLOAT, sizeof(float), value, &index);
}

BindCol() [3/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		double *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_DOUBLE, sizeof(double), value, &index);
}

BindCol() [4/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		INT8 *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_TINYINT, sizeof(INT8), value, &index);
}

BindCol() [5/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		INT16 *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_SHORT, sizeof(INT16), value, &index);
}

BindCol() [6/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		INT32 *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_LONG, sizeof(INT32), value, &index);
}

BindCol() [7/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		INT64 *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_SBIGINT, sizeof(INT64), value, &index);
}

BindCol() [8/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		TIMESTAMP_STRUCT *	value )

{
    SQLLEN index = 0;
    return BindCol(columnIndex, SQL_C_TYPE_TIMESTAMP, sizeof(TIMESTAMP_STRUCT), value, &index);
}

BindCol() [9/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		WCHAR *	str,
		INT32	size,
		SQLLEN *	index )

{
    return BindCol(columnIndex, SQL_C_WCHAR, size, str, index);
}

BindCol() [10/11]

bool JNetDBConn::BindCol	(	INT32	columnIndex,
		BYTE *	bin,
		INT32	size,
		SQLLEN *	index )

{
    return BindCol(columnIndex, SQL_BINARY, size, bin, index);
}

BindParam() [11/11]

bool JNetDBConn::BindParam	(	SQLUSMALLINT	paramIndex,
		SQLSMALLINT	cType,
		SQLSMALLINT	sqlType,
		SQLULEN	len,
		SQLPOINTER	ptr,
		SQLLEN *	index )

{
    // len: 데이터 크기
    // ptr: 전달되는 데이터(포인터)
    // index: 문자열과 같은 가변 길이 데이터에서 필요한 인수, 일반적으로 고정 크기 데이터의 경우 0을 담은 정수 변수의 포인터를 전달
    SQLRETURN ret = ::SQLBindParameter(m_Statement, paramIndex, SQL_PARAM_INPUT, cType, sqlType, len, 0, ptr, 0, index);
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
    {
        HandleError(ret);
        return false;
    }
 
    return true;
}

BindCol() [11/11]

bool JNetDBConn::BindCol	(	SQLUSMALLINT	columnIndex,
		SQLSMALLINT	cType,
		SQLULEN	len,
		SQLPOINTER	value,
		SQLLEN *	index )

{
    SQLRETURN ret = ::SQLBindCol(m_Statement, columnIndex, cType, value, len, index);
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
    {
        HandleError(ret);
        return false;
    }
 
    return true;
}

HandleError() [1/2]

void JNetDBConn::HandleError ( SQLRETURN ret, SQLSMALLINT errMsgBuffLen = 0, SQLWCHAR * errMsgOut = NULL, SQLSMALLINT * errMsgLenOut = NULL )

private

{
    if (ret == SQL_SUCCESS)
        return;
 
    SQLSMALLINT index = 1;
    SQLWCHAR sqlState[MAX_PATH] = { 0 };
    SQLINTEGER nativeErr = 0;
    SQLWCHAR errMsg[MAX_PATH] = { 0 };      // 에러 사유 저장
    SQLSMALLINT msgLen = 0;
    SQLRETURN errorRet = 0;
 
    SQLSMALLINT errMsgOffset = 0;
    if (errMsgLenOut != NULL) {
        *errMsgLenOut = 0;
    }
 
    while (true)
    {
        errorRet = ::SQLGetDiagRecW(    // 에러 메시지 추출 함수
            SQL_HANDLE_STMT,
            m_Statement,
            index,
            sqlState,
            OUT & nativeErr,
            errMsg,
            _countof(errMsg),
            OUT & msgLen
        );
 
        // 에러가 없거나, 성공이 였다면 루프 탈출
        if (errorRet == SQL_NO_DATA)
            break;
        // SQLGetDiagRecW 함수 자체의 에러 반환
        if (errorRet != SQL_SUCCESS && errorRet != SQL_SUCCESS_WITH_INFO)
            break;
 
        if (errMsgBuffLen >= errMsgOffset + msgLen + 1) {
            if (errMsgOut != NULL && errMsgLenOut != NULL) {
                std::wcout.imbue(std::locale("kor"));
                memcpy(&errMsgOut[errMsgOffset], errMsg, sizeof(WCHAR) * msgLen);
                errMsgOut[errMsgOffset + msgLen] = NULL;
                errMsgOffset += (msgLen + 1);
                *errMsgLenOut += msgLen + 1;
            }
        }
 
        index++;
    }
}

HandleError() [2/2]

void JNetDBConn::HandleError ( SQLRETURN ret, SQLSMALLINT hType, SQLHANDLE handle, SQLSMALLINT errMsgBuffLen = 0, SQLWCHAR * errMsgOut = NULL, SQLSMALLINT * errMsgLenOut = NULL )

private

{
    if (ret == SQL_SUCCESS)
        return;
 
    SQLSMALLINT index = 1;
    SQLWCHAR sqlState[MAX_PATH] = { 0 };
    SQLINTEGER nativeErr = 0;
    SQLWCHAR errMsg[MAX_PATH] = { 0 };      // 에러 사유 저장
    SQLSMALLINT msgLen = 0;
    SQLRETURN errorRet = 0;
 
    SQLSMALLINT errMsgOffset = 0;
    if (errMsgLenOut != NULL) {
        *errMsgLenOut = 0;
    }
 
    while (true)
    {
        errorRet = ::SQLGetDiagRecW(    // 에러 메시지 추출 함수
            hType,
            handle,
            index,
            sqlState,
            OUT & nativeErr,
            errMsg,
            _countof(errMsg),
            OUT & msgLen
        );
 
        // 에러가 없거나, 성공이 였다면 루프 탈출
        if (errorRet == SQL_NO_DATA)
            break;
        // SQLGetDiagRecW 함수 자체의 에러 반환
        if (errorRet != SQL_SUCCESS && errorRet != SQL_SUCCESS_WITH_INFO)
            break;
 
        std::wcout << errMsg << std::endl;
 
        if (errMsgBuffLen >= errMsgOffset + msgLen + 1) {
            if (errMsgOut != NULL && errMsgLenOut != NULL) {
                std::wcout.imbue(std::locale("kor"));
                memcpy(&errMsgOut[errMsgOffset], errMsg, sizeof(WCHAR) * msgLen);
                errMsgOut[errMsgOffset + msgLen] = NULL;
                errMsgOffset += (msgLen + 1);
                *errMsgLenOut += msgLen + 1;
            }
        }
 
        index++;
    }
}

ErrorMsgFileLogging()

void JNetDBConn::ErrorMsgFileLogging ( const SQLWCHAR * errMsg, SQLSMALLINT errMsgLen, const std::wstring & filePath )

private

{
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);
    std::tm buf;
    localtime_s(&buf, &in_time_t);
    std::wstringstream ss;
    ss << std::put_time(&buf, L"[%Y.%m.%d %H:%M:%S]");
    std::wstring nowStr = ss.str();
 
    std::lock_guard<std::mutex> lockGuard(m_LogFileMtx);
 
    const wchar_t* ptr;
    std::wofstream outFile(filePath, std::ios::app);  // append 모드로 파일 열기
    if (!outFile) {
        std::wcerr << L"Failed to open file for writing: " << filePath << std::endl;
        return;
    }
 
    outFile << nowStr << std::endl;
 
    for (int i = 0; i < errMsgLen;) {
        ptr = &errMsg[i];
        if (*ptr == L'\0') {
            i++;
        }
        else {
            outFile << ptr << std::endl;
            i += wcslen(ptr) + 1;
        }
    }
 
    outFile << std::endl;
    outFile.close();
}

멤버 데이터 문서화

m_DBConnection

SQLHDBC jnet::JNetDBConn::m_DBConnection = SQL_NULL_HANDLE

private

m_Statement

SQLHSTMT jnet::JNetDBConn::m_Statement = SQL_NULL_HANDLE

private

m_ConnectionErrorFileLogFlag

bool jnet::JNetDBConn::m_ConnectionErrorFileLogFlag

private

m_ConnectionErrLogFile

const wchar_t* jnet::JNetDBConn::m_ConnectionErrLogFile = L"ConnectionErrLog.txt"

private

m_LogFileMtx

std::mutex JNetDBConn::m_LogFileMtx

staticprivate

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• include/JNetDB.h
• JNetCore/JNetDB.cpp