C / C++ / MFC

basementman14-May-03 4:38

basementman

14-May-03 4:38

The following classes should help you. The first is the .H file, followed by the .cpp.

#if !defined(_DBCONN_H_)
#define _DBCONN_H_

#ifdef RETCODE
#undef RETCODE
#endif

#ifndef FAR
#define FAR __far
#endif

#ifdef ODBCVER
#undef ODBCVER
#endif
#define ODBCVER 0x0100
#include <sqlext.h>
#include <afx.h>
#include <malloc.h>

#define STATIC_BUFFER_SIZE 1024

class DBStatement;

class AFX_EXT_CLASS DBConnection
{
protected:

HDBC m_hConnHdl;

long m_lErrorCode;
char m_caErrorMsg[SQL_MAX_MESSAGE_LENGTH];

BOOL m_bDisableStatementScanning;

public:
static HENV m_hEnvironment;

DBConnection();
virtual ~DBConnection();

HDBC GetConnHdl() { return m_hConnHdl; }

BOOL IsDisableStatementScanning() { return m_bDisableStatementScanning; }
void DisableStatementScanning(BOOL bDisable = TRUE) { m_bDisableStatementScanning = bDisable; }

// startup/shutdown functions
static void InitODBC();
static void DeInitODBC();

// connection functions
BOOL Connect(LPCSTR cpDSN, LPCSTR cpUID, LPCSTR cpPWD);
BOOL Disconnect();

// statement functions
DBStatement *ExecSQL(LPCTSTR cpSQLText, DBStatement *pStmt = NULL);

// Error Functions
long GetErrorCode() { return m_lErrorCode; }
LPSTR GetErrorMessage() { return m_caErrorMsg; }
long GetErrorInfo(LPSTR cpErrorText) { if (cpErrorText) strcpy(cpErrorText,m_caErrorMsg); return m_lErrorCode; }

void SetErrorCode(long lErrorCode = 0) { m_lErrorCode = lErrorCode; }
void SetErrorText(LPCSTR cpErrorText) { strcpy(m_caErrorMsg,cpErrorText); }
void SetErrorInfo(long lErrorCode, LPCSTR cpErrorText)
{ m_lErrorCode = lErrorCode; strcpy(m_caErrorMsg,cpErrorText); }

void ResetError() { if (m_lErrorCode) { m_lErrorCode = 0; m_caErrorMsg[0] = 0; } }

void UpdateDBError(HSTMT pStmt = NULL);

};

class AFX_EXT_CLASS DBStatement
{
protected:
HSTMT m_hStmtHdl;
DBConnection *m_pDBConn;

char m_caDataBuf[STATIC_BUFFER_SIZE+1];

BOOL m_bIsDataNull;

BOOL m_bStatementActive;

SYSTEMTIME m_sDateTime;

void InitDataBuffer() { m_caDataBuf[0] = 0; }

public:
DBStatement(DBConnection *pDBConn);
virtual ~DBStatement();

HSTMT GetStmtHdl() { return m_hStmtHdl; }
DBConnection *GetDBConn() { return m_pDBConn; }

BOOL AllocStatement();

BOOL EndSQL();

BOOL IsStatementActive() { return m_bStatementActive; }
void SetStatementActive() { m_bStatementActive = TRUE; }

// data retrieval functions
char *GetString(int iColumnNum, long *lpDataSize = NULL);
void GetString(int iColumnNum, CString *pStr, long *lpDataSize = NULL);
void GetCharBuf(int iColumnNum, char *cpValueBuf, long *lpDataSize = NULL);

double GetDouble(int iColumnNum);
void GetDoubleBuf(int iColumnNum, double *dpValueBuf);

short GetShort(int iColumnNum);
void GetShortBuf(int iColumnNum, short *ipValueBuf);

WORD GetWORD(int iColumnNum) { return (WORD)GetShort(iColumnNum); }
DWORD GetDWORD(int iColumnNum) { return (DWORD)GetLong(iColumnNum); }

long GetLong(int iColumnNum);
void GetLongBuf(int iColumnNum, long *lpValueBuf);

char *GetBinary(int iColumnNum, long *lpDataSize = NULL);
void GetBinary(int iColumnNum, char *cpDataBuf, int iBufferSize, long *lpDataSize = NULL);

SYSTEMTIME *GetDate(int iColumnNum, SYSTEMTIME *spDateTime = NULL);

BYTE *GetBlob(int iColumnNum, long *lpDataSize = NULL);

void SetNullValue(BOOL bIsDataNull = TRUE) { m_bIsDataNull = bIsDataNull; }
BOOL IsNullValue() { return m_bIsDataNull; }

// cursor functions
BOOL FetchNext();

BOOL NextResultSet();

// statement info functions
short GetColType(int iColumnNum); // simplified column type
short GetColDBType(int iColumnNum); // native odbc column type

LPSTR GetColName(int iColumnNum);
void GetColNameBuf(int iColumnNum, LPTSTR cpColNameBuf);

long GetColWidth(int iColumnNum);

int GetNumCols();

// Error Functions
long GetErrorCode() { return m_pDBConn->GetErrorCode(); }
LPSTR GetErrorMessage() { return m_pDBConn->GetErrorMessage(); }
long GetErrorInfo(LPSTR cpErrorText) { return m_pDBConn->GetErrorInfo(cpErrorText); }

void SetErrorCode(long lErrorCode = 0) { m_pDBConn->SetErrorCode(lErrorCode); }
void SetErrorText(LPCSTR cpErrorText) { m_pDBConn->SetErrorText(cpErrorText); }
void SetErrorInfo(long lErrorCode, LPCSTR cpErrorText)
{ m_pDBConn->SetErrorInfo(lErrorCode,cpErrorText); }

void ResetError() { m_pDBConn->ResetError(); }

void UpdateDBError() { m_pDBConn->UpdateDBError(m_hStmtHdl); }

void NoActiveStatement() { SetErrorInfo(-10, "No Active Statement Exists!"); }
};

#endif

///////////////////////////////////

#include "stdafx.h"
#include "dbconn.h"

// init statics
HENV DBConnection::m_hEnvironment = NULL;

DBStatement::DBStatement(DBConnection *pDBConn)
{
m_pDBConn = pDBConn;

m_hStmtHdl = NULL;
m_caDataBuf[0] = 0;
m_bIsDataNull = FALSE;
m_bStatementActive = FALSE;

memset(&m_sDateTime,0,sizeof(SYSTEMTIME));
}

DBStatement::~DBStatement()
{
if (m_hStmtHdl)
{
::SQLFreeStmt(m_hStmtHdl,SQL_DROP);
m_hStmtHdl = NULL;
}
}

BOOL DBStatement::AllocStatement()
{
BOOL bRetval = TRUE;

if (!m_hStmtHdl)
{
short iStatus = ::SQLAllocStmt(m_pDBConn->GetConnHdl(),&m_hStmtHdl);
if (iStatus == SQL_SUCCESS)
{
::SQLSetStmtOption(m_hStmtHdl,SQL_ASYNC_ENABLE,SQL_ASYNC_ENABLE_OFF);

if (m_pDBConn->IsDisableStatementScanning())
::SQLSetStmtOption(m_hStmtHdl,SQL_NOSCAN,SQL_NOSCAN_ON);
}
else
{
SetErrorInfo(-8, "Unable to allocate statement handle!");
bRetval = FALSE;
m_hStmtHdl = NULL;
}
}

return bRetval;
}

BOOL DBStatement::EndSQL()
{
BOOL bRetval = FALSE;

if (m_hStmtHdl)
{
m_bStatementActive = FALSE;
bRetval = TRUE;
::SQLFreeStmt(m_hStmtHdl,SQL_CLOSE);
m_hStmtHdl = NULL;
}
else
NoActiveStatement();

return bRetval;
}

char *DBStatement::GetString(int iColumnNum, long *lpDataSize /*=NULL*/)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
InitDataBuffer();

long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_CHAR,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
m_caDataBuf[0] = 0;
else
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
{
iStatus = SQL_SUCCESS;
m_caDataBuf[STATIC_BUFFER_SIZE] = 0;
}
else
{
if (lColSize != SQL_NO_TOTAL && lColSize <= STATIC_BUFFER_SIZE)
m_caDataBuf[lColSize] = 0;
}
}

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();

if (iStatus != SQL_SUCCESS)
m_caDataBuf[0] = 0;

return m_caDataBuf;
}

void DBStatement::GetString(int iColumnNum, CString *pStr, long *lpDataSize /*=NULL*/)
{
short iStatus = -1;

pStr->Empty();

if (m_hStmtHdl)
{
ResetError();
InitDataBuffer();

long lColSize = 0;
long lDataReturned = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_CHAR,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lDataReturned);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lDataReturned == SQL_NULL_DATA)
{
lColSize = 0;
}
else
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
{
while (iStatus == SQL_SUCCESS_WITH_INFO && lDataReturned > 0)
{
lColSize += STATIC_BUFFER_SIZE;
m_caDataBuf[STATIC_BUFFER_SIZE] = 0;
*pStr += m_caDataBuf;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_CHAR,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lDataReturned);
}

if (iStatus == SQL_SUCCESS)
{
lColSize += (lDataReturned - 1);
m_caDataBuf[min(STATIC_BUFFER_SIZE,lDataReturned)] = 0;
*pStr += m_caDataBuf;
}

m_caDataBuf[0] = 0;

iStatus = SQL_SUCCESS;
}
else
{
if (lDataReturned != SQL_NO_TOTAL && lDataReturned <= STATIC_BUFFER_SIZE)
m_caDataBuf[lDataReturned] = 0;

lColSize = lDataReturned;
}
}

if (lColSize > 0 && m_caDataBuf[0])
*pStr += m_caDataBuf;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();

if (iStatus != SQL_SUCCESS)
pStr->Empty();
}

void DBStatement::GetCharBuf(int iColumnNum, char *cpValueBuf, long *lpDataSize /*=NULL*/)
{
short iStatus = -1;

*cpValueBuf = 0;

if (m_hStmtHdl)
{
ResetError();
InitDataBuffer();

long lColSize = 0;
long lDataReturned = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_CHAR,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lDataReturned);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lDataReturned == SQL_NULL_DATA)
{
lColSize = 0;
m_caDataBuf[0] = 0;
}
else
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
{
while (iStatus == SQL_SUCCESS_WITH_INFO && lDataReturned > 0)
{
lColSize += STATIC_BUFFER_SIZE;
m_caDataBuf[STATIC_BUFFER_SIZE] = 0;
strcat(cpValueBuf,m_caDataBuf);

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_CHAR,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lDataReturned);
}

if (iStatus == SQL_SUCCESS)
{
lColSize += (lDataReturned - 1);
m_caDataBuf[min(STATIC_BUFFER_SIZE,lDataReturned)] = 0;
strcat(cpValueBuf,m_caDataBuf);
}

m_caDataBuf[0] = 0;

iStatus = SQL_SUCCESS;
}
else
{
if (lDataReturned != SQL_NO_TOTAL && lDataReturned <= STATIC_BUFFER_SIZE)
m_caDataBuf[lDataReturned] = 0;

lColSize = lDataReturned;
}
}

if (lColSize > 0 && m_caDataBuf[0])
strcat(cpValueBuf,m_caDataBuf);

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();

if (iStatus != SQL_SUCCESS)
*cpValueBuf = 0;
}

double DBStatement::GetDouble(int iColumnNum)
{
double dRetval = 0.0;
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_DOUBLE,(LPSTR)&dRetval,8,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
dRetval = 0.0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();

return dRetval;
}

void DBStatement::GetDoubleBuf(int iColumnNum, double *dpValueBuf)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_DOUBLE,(LPSTR)dpValueBuf,8,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
*dpValueBuf = 0.0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();
}

short DBStatement::GetShort(int iColumnNum)
{
short iRetval = 0;
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_SHORT,(LPSTR)&iRetval,2,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
iRetval = 0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();

return iRetval;
}

void DBStatement::GetShortBuf(int iColumnNum, short *ipValueBuf)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_SHORT,(LPSTR)ipValueBuf,2,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
*ipValueBuf = 0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();
}

long DBStatement::GetLong(int iColumnNum)
{
long lRetval = 0;
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_LONG,(LPSTR)&lRetval,4,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
lRetval = 0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();

return lRetval;
}

void DBStatement::GetLongBuf(int iColumnNum, long *lpValueBuf)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_LONG,(LPSTR)lpValueBuf,4,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
*lpValueBuf = 0;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();
}
else
NoActiveStatement();
}

char *DBStatement::GetBinary(int iColumnNum, long *lpDataSize /*=NULL*/)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();
InitDataBuffer();

memset(m_caDataBuf,0,STATIC_BUFFER_SIZE);
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_BINARY,(LPSTR)m_caDataBuf,STATIC_BUFFER_SIZE,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
iStatus = SQL_SUCCESS;

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();

return m_caDataBuf;
}

void DBStatement::GetBinary(int iColumnNum, char *cpDataBuf, int iBufferSize, long *lpDataSize /*=NULL*/)
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();

long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_BINARY,(LPSTR)cpDataBuf,iBufferSize,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize == SQL_NULL_DATA)
memset(cpDataBuf,0,iBufferSize);
else
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
iStatus = SQL_SUCCESS;
}

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();
}

SYSTEMTIME *DBStatement::GetDate(int iColumnNum, SYSTEMTIME *spDateTime /*=NULL*/)
{
short iStatus = -1;

if (!spDateTime)
spDateTime = &m_sDateTime;

memset(spDateTime,0,sizeof(SYSTEMTIME));

if (m_hStmtHdl)
{
ResetError();

SQL_TIMESTAMP_STRUCT sTS;
long lColSize = 0;

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_TIMESTAMP,&sTS,sizeof(SQL_TIMESTAMP_STRUCT),&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (iStatus == SQL_SUCCESS_WITH_INFO)
iStatus = SQL_SUCCESS;

SetNullValue(lColSize == SQL_NULL_DATA);
if (lColSize != SQL_NULL_DATA)
{
spDateTime->wYear = sTS.year;
spDateTime->wMonth = sTS.month;
spDateTime->wDay = sTS.day;
spDateTime->wHour = sTS.hour;
spDateTime->wMinute = sTS.minute;
spDateTime->wSecond = sTS.second;
// spDateTimeStruct->wMilliseconds = (USHORT)sTS.fraction;
}
}
else
UpdateDBError();
}
else
NoActiveStatement();

return spDateTime;
}

BYTE *DBStatement::GetBlob(int iColumnNum, long *lpDataSize /*=NULL*/)
{
BYTE *pRetval = NULL;
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();

long lColSize = 0;
char caDummy[20];

iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_BINARY,caDummy,0,&lColSize);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
{
if (lColSize != SQL_NULL_DATA)
{
if (iStatus == SQL_SUCCESS_WITH_INFO && lColSize > 0)
{
pRetval = new BYTE[lColSize+1]; // add 1 just in case
iStatus = ::SQLGetData(m_hStmtHdl,iColumnNum,SQL_C_BINARY,pRetval,lColSize,&lColSize);
if (iStatus != SQL_SUCCESS)
{
UpdateDBError();
delete [] pRetval;
pRetval = NULL;
}
else
*(pRetval+lColSize) = 0; // null terminate
}
}

SetNullValue(lColSize == SQL_NULL_DATA);
}
else
UpdateDBError();

if (lpDataSize)
*lpDataSize = lColSize;
}
else
NoActiveStatement();

return pRetval;
}

BOOL DBStatement::FetchNext()
{
short iStatus = -1;

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLFetch(m_hStmtHdl);
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO)
iStatus = SQL_SUCCESS;
else
UpdateDBError();
}
else
NoActiveStatement();

return (iStatus == SQL_SUCCESS);
}

BOOL DBStatement::NextResultSet()
{
BOOL bRetval = FALSE;

if (m_hStmtHdl)
{
ResetError();

if (::SQLMoreResults(m_hStmtHdl) == SQL_SUCCESS)
bRetval = TRUE;
}
else
NoActiveStatement();

return bRetval;
}

short DBStatement::GetColType(int iColumnNum)
{
short iRetval = -1;

ResetError();

short iColType = GetColDBType(iColumnNum);
switch(iColType){
case SQL_CHAR:
iRetval = 1;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
iRetval = 2;
break;
case SQL_NUMERIC:
case SQL_DECIMAL:
iRetval = 3;
break;
case SQL_INTEGER:
iRetval = 4;
break;
case SQL_BIT:
case SQL_TINYINT:
case SQL_SMALLINT:
iRetval = 5;
break;
case SQL_FLOAT:
case SQL_REAL:
iRetval = 6;
break;
case SQL_DOUBLE:
iRetval = 7;
break;
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
iRetval = 8;
break;
case SQL_BINARY:
case SQL_VARBINARY:
iRetval = 9;
break;
case SQL_LONGVARBINARY: // blob
iRetval = 10;
break;
default:
iRetval = 2; // default to varchar...
break;
}

return iRetval;
}

short DBStatement::GetColDBType(int iColumnNum)
{
short iStatus;
char caDummy[2];
short iDummy;
long lColType = -1;

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLColAttributes(m_hStmtHdl,(UWORD)iColumnNum,(UWORD)SQL_COLUMN_TYPE,(PTR)caDummy,(SWORD)1,(SWORD *)&iDummy,(SDWORD *)&lColType);
if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
{
UpdateDBError();
lColType = -1;
}
}
else
NoActiveStatement();

return (short)lColType;
}

LPSTR DBStatement::GetColName(int iColumnNum)
{
short iStatus;
long lDummy;
short iDummy;

InitDataBuffer();

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLColAttributes(m_hStmtHdl,(UWORD)iColumnNum,(UWORD)SQL_COLUMN_NAME,(PTR)m_caDataBuf,(SWORD)1000,(SWORD *)&iDummy,(SDWORD *)&lDummy);
if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
{
UpdateDBError();
m_caDataBuf[0] = 0;
}
}
else
NoActiveStatement();

return m_caDataBuf;
}

void DBStatement::GetColNameBuf(int iColumnNum, LPTSTR cpColNameBuf)
{
short iStatus;
long lDummy;
short iDummy;

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLColAttributes(m_hStmtHdl,(UWORD)iColumnNum,(UWORD)SQL_COLUMN_NAME,(PTR)cpColNameBuf,(SWORD)1000,(SWORD *)&iDummy,(SDWORD *)&lDummy);
if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
{
UpdateDBError();
*cpColNameBuf = 0;
}
}
else
NoActiveStatement();
}

long DBStatement::GetColWidth(int iColumnNum)
{
short iStatus;
char caDummy[2];
long lColWidth = -1;
short iDummy;

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLColAttributes(m_hStmtHdl,(UWORD)iColumnNum,(UWORD)SQL_COLUMN_LENGTH,(PTR)caDummy,(SWORD)1,(SWORD *)&iDummy,(SDWORD *)&lColWidth);
if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
UpdateDBError();
}
else
NoActiveStatement();

return lColWidth;
}

int DBStatement::GetNumCols()
{
short iStatus;
short iRetval = -1;

if (m_hStmtHdl)
{
ResetError();

iStatus = ::SQLNumResultCols(m_hStmtHdl,(short *)&iRetval);
if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
UpdateDBError();
}
else
NoActiveStatement();

return (int)iRetval;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

DBConnection::DBConnection()
{
m_hConnHdl = NULL;
m_lErrorCode = 0;
m_caErrorMsg[0] = 0;

m_bDisableStatementScanning = FALSE;
}

DBConnection::~DBConnection()
{
if (m_hConnHdl)
Disconnect();
}

void DBConnection::InitODBC()
{
if (!m_hEnvironment)
::SQLAllocEnv(&m_hEnvironment);
}

void DBConnection::DeInitODBC()
{
if (m_hEnvironment)
{
::SQLFreeEnv(m_hEnvironment);
m_hEnvironment = NULL;
}
}

void DBConnection::UpdateDBError(HSTMT pStmt /*=NULL*/)
{
char caSQLState[21];
short iError = -1;

caSQLState[0] = 0;
m_caErrorMsg[0] = 0;

::SQLError(m_hEnvironment,m_hConnHdl,pStmt,(unsigned char *)caSQLState,&m_lErrorCode,(unsigned char *)m_caErrorMsg,sizeof(m_caErrorMsg)-1,(short *)&iError);
}

BOOL DBConnection::Connect(LPCSTR cpDSN, LPCSTR cpUID, LPCSTR cpPWD)
{
if (m_hConnHdl)
{
SetErrorInfo(-5,"Already Connected!");
return FALSE;
}

ResetError();

short iStatus = ::SQLAllocConnect(m_hEnvironment,&m_hConnHdl);
if (iStatus == SQL_SUCCESS)
{
iStatus = ::SQLConnect(m_hConnHdl,
(UCHAR *)cpDSN,(SWORD)strlen(cpDSN),
(UCHAR *)cpUID,(SWORD)strlen(cpUID),
(UCHAR *)cpPWD,(SWORD)strlen(cpPWD));

if (iStatus != SQL_SUCCESS && iStatus != SQL_SUCCESS_WITH_INFO)
{
UpdateDBError();
::SQLFreeConnect(m_hConnHdl);
m_hConnHdl = NULL;
}

iStatus = 0;
}
else
{
m_hConnHdl = NULL;
}

if (iStatus)
UpdateDBError();

return (m_hConnHdl != NULL);
}

BOOL DBConnection::Disconnect()
{
short iStatus = -1;

if (m_hConnHdl)
{
iStatus = ::SQLDisconnect(m_hConnHdl);
if (iStatus == SQL_SUCCESS)
{
iStatus = ::SQLFreeConnect(m_hConnHdl);
m_hConnHdl = NULL;
}
else
UpdateDBError();
}
else
{
SetErrorInfo(-6,"Not Connected!");
}

return (iStatus == SQL_SUCCESS);
}

DBStatement *DBConnection::ExecSQL(LPCTSTR cpSQLText, DBStatement *pStmt /*=NULL*/)
{
DBStatement *pRetval = NULL;

if (m_hConnHdl)
{
if (pStmt)
pRetval = pStmt;
else
pRetval = new DBStatement(this);

if (pRetval)
{
if (pRetval->AllocStatement())
{
short iStatus = ::SQLExecDirect(pRetval->GetStmtHdl(),
(unsigned char *)cpSQLText,
strlen(cpSQLText));
if (iStatus == SQL_SUCCESS || iStatus == SQL_SUCCESS_WITH_INFO || iStatus == SQL_NO_DATA_FOUND)
{
iStatus = SQL_SUCCESS;
pRetval->SetStatementActive();
}
else
{
UpdateDBError(pRetval->GetStmtHdl());

if (!pStmt)
delete pRetval;
else
pStmt->EndSQL();

pRetval = NULL;
}
}
else
{
if (!pStmt)
delete pRetval;

pRetval = NULL;
}
}
}
else
{
SetErrorInfo(-6,"Not Connected!");
}

return pRetval;
}

////////////////////

In your main startup function, add the line:

DBConnection::InitODBC();

In your exit function add the line

DBConnection::DeInitODBC();

In your processing function, add the following code:

DBConnection oDBConn;

if (oDBConn.Connect("Database1", "sa", "the sa password"))
{
DBStatement *pStmt = oDBConn.ExecSQL("exec databasename..sp1");
if (pStmt)
{
int iIndex = 0;
while (pStmt->FetchNext())
{
YourArray[iIndex] = pStmt->GetString | pStmt->GetLong | pStmt->GetDouble.... etc.

iIndex++;
}

pStmt->EndSQL();

delete pStmt;
}
else
{
// handle error using oDBConn.GetErrorCode,
// oDBConn.GetErrorMessage, etc..
}

oDBConn.Disconnect();
}
else
{
// handle error using oDBConn.GetErrorCode,
// oDBConn.GetErrorMessage, etc..
}

Hope this helps...

Unplugged14-May-03 7:19

Unplugged

14-May-03 7:19

I can't get the files to compile. Unsure | :~

ICXC
NIKA

basementman14-May-03 8:14

basementman

14-May-03 8:14

Why not?

Unplugged14-May-03 8:21

Unplugged

14-May-03 8:21

below are the errors it gives me.

Don't worry about it. I'm sick of trying to figure this out. If they want it done, they can do it themselves. Roll eyes | :rolleyes:

c:\program files\microsoft visual studio\vc98\include\sqltypes.h(114) : error C2146: syntax error : missing ';' before identifier 'SQLHWND'
c:\program files\microsoft visual studio\vc98\include\sqltypes.h(114) : fatal error C1004: unexpected end of file found
PointerTestMain.cpp
c:\program files\microsoft visual studio\vc98\include\sqltypes.h(114) : error C2146: syntax error : missing ';' before identifier 'SQLHWND'
c:\program files\microsoft visual studio\vc98\include\sqltypes.h(114) : fatal error C1004: unexpected end of file found
dbconn.cpp
c:\parsells\c++ testing\ddl checker db connect\dbconn.h(54) : error C2143: syntax error : missing ';' before '*'
c:\parsells\c++ testing\ddl checker db connect\dbconn.h(54) : error C2501: 'DBStatement' : missing storage-class or type specifiers
c:\parsells\c++ testing\ddl checker db connect\dbconn.h(54) : error C2061: syntax error : identifier 'DBStatement'
c:\parsells\c++ testing\ddl checker db connect\dbconn.h(54) : error C2501: 'ExecSQL' : missing storage-class or type specifiers
c:\parsells\c++ testing\ddl checker db connect\dbconn.cpp(952) : error C2511: 'ExecSQL' : overloaded member function 'class DBStatement *(const char *,class DBStatement *)' not found in 'DBConnection'
c:\parsells\c++ testing\ddl checker db connect\dbconn.h(24) : see declaration of 'DBConnection'

ICXC
NIKA

Dragging a rectangle

Franz Klein14-May-03 4:03

Franz Klein

14-May-03 4:03

Does anybody know of code that will show a rectangle being draw as one holds the left mouse button down and drags the the mouse along?

Smile | :)

Re: Dragging a rectangle

basementman14-May-03 4:57

basementman

14-May-03 4:57

Look up DrawFocusRect() in the online doc.

Re: Dragging a rectangle

John R. Shaw14-May-03 7:00

John R. Shaw

14-May-03 7:00

Search code project for paint type programs (there is more than one).

Trust in the code Luke. Yea right!

Re: Dragging a rectangle

Anonymous14-May-03 22:42

14-May-03 22:42

CRectTracker !!!
CRectTracker !!!
CRectTracker !!!

CFileDialog problem

Anonymous14-May-03 3:36

14-May-03 3:36

I have an unusual problem, which I hope some of you can help with.

I have an application which uses a CFileDialog to ask the user for a file path. Nothing unusual in that. Should be straightforward. The CFileDialog is only ever called in the user interface thread.

On most computers the code works fine. It simply calls the constructor with appropriate arguments and calls DoModal(). On some computers the code works fine most of the time and then occasionally bombs out. It doesn't appear to matter if the various parameters are set to definite values, or to the defaults (this has been tested, it is not a guess).

I cannot reproduce the problem and hence it is hard for me to diagnose, other than the information above.

I've tried looking on the web, microsoft and all the usual places and can't find any reference to this problem at all.

Has anyone come across this problem before, and do they know how to fix it?

VC++ 6.0, dynamically linked to MFC. Target: NT/2000/XP.

Cheers

Stephen
(posting anonymous as this machine has never seen me before (no cookie) and I can't remember my PW).

David Crow14-May-03 3:45

David Crow

14-May-03 3:45

Anonymous wrote:
The CFileDialog is only ever called in the user interface thread.

Can we infer that this is a multi-threaded application?

Anonymous14-May-03 3:51

14-May-03 3:51

DavidCrow wrote:
Anonymous wrote:
The CFileDialog is only ever called in the user interface thread.

Can we infer that this is a multi-threaded application?

Yes. Sorry I should have been more explicit.

David Crow14-May-03 4:19

David Crow

14-May-03 4:19

The first thing I'd try is to "remove" all but the primary thread, unless CFileDialog relies upon the existence of another thread. Since the problem is intermittent, I wouldn't dismiss the possibility of the primary thread "butting heads" with some other thread. Were that the case, I would expect the program to just crash rather than simply not display a dialog box.

Anonymous14-May-03 5:53

14-May-03 5:53

DavidCrow wrote:
The first thing I'd try is to "remove" all but the primary thread, unless CFileDialog relies upon the existence of another thread.

Not an option I'm afraid. Without the other threads, you'll never get to the point where you can click to get the CFileDialog.

 Since the problem is intermittent, I wouldn't dismiss the possibility of the primary thread "butting heads" with some other thread. Were that the case, I would expect the program to just crash rather than simply not display a dialog box. 

So would I.

Amihai14-May-03 3:49

Amihai

14-May-03 3:49

I have the same problem with CFileDialog myself.
It crashes on the destructor of the CFileDialog... WTF | :WTF:

It only happens in a file where I use MS-Word Automation (if that helps someone).

Appreceate any help on this.

Amihai

Anonymous14-May-03 3:55

14-May-03 3:55

Amihai wrote:
I have the same problem with CFileDialog myself.
It crashes on the destructor of the CFileDialog...
It only happens in a file where I use MS-Word Automation (if that helps someone).

The crash I am seeing is somewhere inside OLEAUT32.dll (I think). The code never manages to display the CFileDialog,
let alone reach the destructor.

Stephen

Anonymous14-May-03 4:11