Aqui una clase cuando no tengan otra alternativa que conectarse via ODBC a una base de datos. La parte de manejo de excepciones y escribir el tracing en algun archivo los dejo a su criterio.

#include <afx.h>
#include <stdio.h>
#include <sql.h>
#include <sqlext.h>
#include "CManODBC.h"
#include "dberr.h"
#include "clogmessage.h"

CBasODBC::CBasODBC()
{
}

CBasODBC::~CBasODBC()
{
 mFinalizar();
}

BOOL    CBasODBC::mInitODBC()
{
    RETCODE nRetCode;   

    nRetCode = SQLSetEnvAttr(
                m_henv,
                SQL_ATTR_ODBC_VERSION,
                (SQLPOINTER) SQL_OV_ODBC3,
                SQL_IS_INTEGER);

    if (nRetCode != SQL_SUCCESS && nRetCode == SQL_SUCCESS_WITH_INFO)
    {    

        return  FALSE;
    }

    return  TRUE;
}

BOOL CBasODBC::mErrorODBC(
            LPSTR lpszODBCApiCmd,
            RETCODE rc,
            HENV    henv,
            HDBC    hdbc,
            HSTMT   hstmt)
{
    UCHAR   szSQLStateΔ], szErrorMsg[SQL_MAX_MESSAGE_LENGTH]
 CHAR szMsg[SQL_MAX_MESSAGE_LENGTH]
    SDWORD  NativeError;
    SWORD   cbErrorMsg;
    RETCODE nRetCode;
    INT     nError = 0;
 CLogMessage LogMessage;

    ZeroMemory(szSQLState, sizeof(szSQLState));
    ZeroMemory(szErrorMsg, sizeof(szErrorMsg));
 ZeroMemory(szMsg, sizeof(szMsg));

    nRetCode = SQLError(henv,
                       ≈nbsp;    hdbc,
                            hstmt,
                            szSQLState,
                            &NativeError,
                            szErrorMsg,
                            SQL_MAX_MESSAGE_LENGTH - 1,
                            &cbErrorMsg);

    sprintf(szMsg,"[Error al Ejecutar : %s] [Ret %d] [SQLError :%s] [State %s]\n",
                      lpszODBCApiCmd, rc, szErrorMsg, szSQLState);

 LogMessage.Grabar(szMsg);
 return TRUE;
}

BOOL CBasODBC::mInicializar(LPSTR DSN, LPSTR User, LPSTR Passwd)
{
 
 RETCODE retcode;

 __try {

  retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE ,&m_henv);// Allocate environment handle

  if (retcode == SQL_SUCCESS)
  {
   if (mInitODBC() == TRUE)
   {
    retcode = SQLAllocHandle(SQL_HANDLE_DBC, m_henv, &m_hdbc); // Allocate connection handle

    if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
    {
     retcode = SQLSetConnectAttr(m_hdbc, SQL_LOGIN_TIMEOUT, (void *)10, 0);
     
     retcode = SQLConnect(m_hdbc, (SQLCHAR*) DSN   , SQL_NTS,
             (SQLCHAR*) User  , SQL_NTS,
             (SQLCHAR*) Passwd, SQL_NTS);

     if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INF)
     {
      // Process data after successful connection
       return TRUE;   
     }
    }   
   }  
  }

  return FALSE;
 }

 __except ( ExceptionFilter(GetExceptionCode( ),GetExceptionInformation()))
 {
  return FALSE;
 }
}

BOOL CBasODBC::mFinalizar(void)
{
 __try { 
  SQLDisconnect(m_hdbc);        
  SQLFreeHandle(SQL_HANDLE_DBC, m_hdbc);
  SQLFreeHandle(SQL_HANDLE_ENV, m_henv);
  return TRUE;
 }
 __except ( ExceptionFilter( GetExceptionCode( ),GetExceptionInformation()))
 {
  return FALSE;
 }
}

BOOL CBasODBC::mInicioTransaccion()
{

 char sStm𖑷]

 ZeroMemory(sStm, sizeof(sStm));
 strcpy(sStm, " BEGIN TRANSACTION ");
 return mEjecutarSQL(sStm);
}

BOOL CBasODBC::mRollBackTransaccion()
{
 char sStm𖑷]

 ZeroMemory(sStm, sizeof(sStm));
 strcpy(sStm, " ROLLBACK TRANSACTION ");
 return mEjecutarSQL(sStm);
}

BOOL CBasODBC::mFinTransaccion()
{
 char sStm𖑷]

 ZeroMemory(sStm, sizeof(sStm));
 strcpy(sStm, " COMMIT TRANSACTION ");
 return mEjecutarSQL(sStm);
}