CODE HERE A FOLOWS:


namespace ODBC {

#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include <windows.h>

#include <sql.h>
#include <sqlext.h>

#include <odbcinst.h>
//--
#pragma comment(lib,"odbc32.lib")
#pragma comment(lib,"odbcbcp.lib")
#pragma comment(lib,"OdbcCP32.Lib")
//--
#define IS_SQL_ERR !IS_SQL_OK
#define IS_SQL_OK(res) (res==SQL_SUCCESS_WITH_INFO || res==SQL_SUCCESS)
#define SAFE_STR(str) ((str==NULL) ? _T("") : str)
//--
enum sqlDataTypes {
sqlDataTypeUnknown = SQL_UNKNOWN_TYPE, sqlDataTypeChar = SQL_CHAR,
sqlDataTypeNumeric = SQL_NUMERIC, sqlDataTypeDecimal = SQL_DECIMAL,
sqlDataTypeInteger = SQL_INTEGER, sqlDataTypeSmallInt = SQL_SMALLINT,
sqlDataTypeFloat = SQL_FLOAT, sqlDataTypeReal = SQL_REAL,
sqlDataTypeDouble = SQL_DOUBLE,
#if (ODBCVER >= 0x0300)
sqlDataTypeDateTime = SQL_DATETIME,
#endif
sqlDataTypeVarChar = SQL_VARCHAR
};



//--
class DSNConnection {
public:
bool Connect(LPCTSTR svSource, LPCTSTR szUsername, LPCTSTR szPassword) {
int nConnect = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, & m_hEnv);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
nConnect = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION,
(void *) SQL_OV_ODBC3, 0);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
nConnect = SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, & m_hDBC);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
SQLSetConnectOption(m_hDBC, SQL_LOGIN_TIMEOUT, 5);
nConnect = SQLConnect(m_hDBC, (SQLTCHAR *) svSource, SQL_NTS,
(SQLTCHAR *) szUsername, SQL_NTS,
(SQLTCHAR *) szPassword, SQL_NTS);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
return 1;
}
}
}
}
if(m_hDBC != NULL) {
m_nReturn = SQLDisconnect(m_hDBC);
m_nReturn = SQLFreeHandle(SQL_HANDLE_DBC, m_hDBC);
}
if(m_hEnv != NULL)
m_nReturn = SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
m_hDBC = NULL;
m_hEnv = NULL;
m_nReturn = SQL_ERROR;
return 0;
}

DSNConnection() {
m_hDBC = NULL;
m_hEnv = NULL;
m_nReturn = SQL_ERROR;
}

virtual ~DSNConnection() {
if(m_hDBC != NULL) {
m_nReturn = SQLFreeHandle(SQL_HANDLE_DBC, m_hDBC);
}
if(m_hEnv != NULL)
m_nReturn = SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
}

void Disconnect() {
if(m_hDBC != NULL) {
m_nReturn = SQLDisconnect(m_hDBC);
m_hDBC = NULL;
}
}

public:
operator HDBC() {
return m_hDBC;
}

private:
SQLRETURN m_nReturn; // Internal SQL Error code
HENV m_hEnv; // Handle to environment
HDBC m_hDBC; // Handle to database connection
};



//--
class ODBCConnection {
public:
bool Connect(LPCTSTR svSource) {
int nConnect = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, & m_hEnv);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
nConnect = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION,
(void *) SQL_OV_ODBC3, 0);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
nConnect = SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, & m_hDBC);
if(nConnect == SQL_SUCCESS || nConnect == SQL_SUCCESS_WITH_INFO) {
SQLSetConnectOption(m_hDBC, SQL_LOGIN_TIMEOUT, 5);
short shortResult = 0;
SQLTCHAR szOutConnectString[1024];
nConnect = SQLDriverConnect(m_hDBC, // Connection Handle
NULL, // Window Handle
(SQLTCHAR *) svSource, // InConnectionString
_tcslen(svSource), // StringLength1
szOutConnectString, // OutConnectionString
sizeof(szOutConnectString), // Buffer length
& shortResult, // StringLength2Ptr
SQL_DRIVER_NOPROMPT); // no User prompt
return IS_SQL_OK(nConnect);
}
}
}
if(m_hDBC != NULL) {
m_nReturn = SQLDisconnect(m_hDBC);
m_nReturn = SQLFreeHandle(SQL_HANDLE_DBC, m_hDBC);
}
if(m_hEnv != NULL)
m_nReturn = SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
m_hDBC = NULL;
m_hEnv = NULL;
m_nReturn = SQL_ERROR;
return (IS_SQL_OK(nConnect));
}

ODBCConnection() {
m_hDBC = NULL;
m_hEnv = NULL;
m_nReturn = SQL_ERROR;
}

virtual ~ODBCConnection() {
if(m_hDBC != NULL) {
m_nReturn = SQLFreeHandle(SQL_HANDLE_DBC, m_hDBC);
}
if(m_hEnv != NULL)
m_nReturn = SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
}

void Disconnect() {
if(m_hDBC != NULL) {
m_nReturn = SQLDisconnect(m_hDBC);
m_hDBC = NULL;
}
}

public:
operator HDBC() {
return m_hDBC;
}

private:
SQLRETURN m_nReturn; // Internal SQL Error code
HENV m_hEnv; // Handle to environment
HDBC m_hDBC; // Handle to database connection
};



//--
class MSSQLConnection : public ODBCConnection {
public:
enum enumProtocols {
protoNamedPipes, protoWinSock, protoIPX, protoBanyan, protoRPC
};

public:
MSSQLConnection() {
};

virtual ~MSSQLConnection() {
};

BOOL Connect(LPCTSTR User = _T(""), LPCTSTR Pass = _T(""), LPCTSTR Host = _T("(local)"),
BOOL Trusted = 1, enumProtocols Proto = protoNamedPipes) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={SQL Server};Server=%s;Uid=%s;Pwd=%s;Trusted_Connection=%s;Network=%s;"),
SAFE_STR(Host), SAFE_STR(User), SAFE_STR(Pass),
(Trusted ? _T("Yes") : _T("No")));
switch(Proto) {
case protoNamedPipes:
_tcscat(str, _T("dbnmpntw"));
break;
case protoWinSock:
_tcscat(str, _T("dbmssocn"));
break;
case protoIPX:
_tcscat(str, _T("dbmsspxn"));
break;
case protoBanyan:
_tcscat(str, _T("dbmsvinn"));
break;
case protoRPC:
_tcscat(str, _T("dbmsrpcn"));
break;
default:
_tcscat(str, _T("dbmssocn"));
break;
}
_tcscat(str, _T(";"));
return ODBCConnection::Connect(str);
};
};



//--
class DB2Connection : private ODBCConnection {
public:
DB2Connection() {
};

virtual ~DB2Connection() {
};

int Connect(LPCTSTR DBPath) {
TCHAR str[512] = _T("");
_stprintf(str, _T("Driver={Microsoft dBASE Driver (*.dbf)};DriverID=277;Dbq=%s;"),
SAFE_STR(DBPath));
return ODBCConnection::Connect(str);
};
};



//--
class XLSConnection : private ODBCConnection {
public:
XLSConnection() {
};

virtual ~XLSConnection() {
};

int Connect(LPCTSTR XLSPath, LPCTSTR DefDir = _T("")) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={Microsoft Excel Driver (*.xls)};DriverId=790;bq=%s;DefaultDir=%s;"),
SAFE_STR(XLSPath), SAFE_STR(DefDir));
return ODBCConnection::Connect(str);
};
};



//--
class TXTConnection : private ODBCConnection {
public:
TXTConnection() {
};

int Connect(LPCTSTR TXTPath) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={Microsoft Text Driver (*.txt; *.csv)};Dbq=%s;Extensions=asc,csv,tab,txt;"),
SAFE_STR(TXTPath));
return ODBCConnection::Connect(str);
};
};



//--
class FOXConnection : public ODBCConnection {
public:
FOXConnection() {
};

virtual ~FOXConnection() {
};

int Connect(LPCTSTR DBPath, LPCTSTR User = _T(""), LPCTSTR Pass = _T(""),
LPCTSTR Type = _T("DBF"), BOOL Exclusive = 0) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={Microsoft Visual Foxpro Driver};Uid=%s;Pwd=%s;SourceDB=%s;SourceType=%s;Exclusive=%s;"),
SAFE_STR(User), SAFE_STR(Pass), SAFE_STR(DBPath), SAFE_STR(Type),
(Exclusive ? _T("yes") : _T("no")));
return ODBCConnection::Connect(str);
};
};



//--
class MDBConnection : public ODBCConnection {
public:
MDBConnection() {
};

virtual ~MDBConnection() {
};

int Connect(LPCTSTR MDBPath, LPCTSTR User = _T(""), LPCTSTR Pass = _T(""),
BOOL Exclusive = 0) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={Microsoft Access Driver (*.mdb)};Dbq=%s;Uid=%s;Pwd=%s;Exclusive=%s;"),
SAFE_STR(MDBPath), SAFE_STR(User), SAFE_STR(Pass),
(Exclusive ? _T("yes") : _T("no")));
return ODBCConnection::Connect(str);
};
};



//--
class mySQLConnection : public ODBCConnection {
public:
mySQLConnection() {
};

virtual ~mySQLConnection() {
};

int Connect(LPCTSTR User = _T(""), LPCTSTR Pass = _T(""), LPCTSTR Host = _T("localhost"),
UINT Port = 3306, UINT Option = 0) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={MySQL ODBC 3.51 Driver};Uid=%s;Pwd=%s;Server=%s;Port=%d;"),
SAFE_STR(User), SAFE_STR(Pass), SAFE_STR(Host), Port);
return ODBCConnection::Connect(str);
};

int ConnectDB(LPCTSTR DB, LPCTSTR User = _T(""), LPCTSTR Pass = _T(""),
LPCTSTR Host = _T("localhost"), UINT Port = 3306, UINT Option = 0) {
TCHAR str[512] = _T("");
_stprintf(str,
_T("Driver={MySQL ODBC 3.51 Driver};Database=%s;Uid=%s;Pwd=%s;Server=%s;Port=%d;"),
SAFE_STR(DB), SAFE_STR(User), SAFE_STR(Pass), SAFE_STR(Host), Port);
return ODBCConnection::Connect(str);
};
};



//--
class ODBCStmt {
HSTMT m_hStmt;

public:
operator HSTMT() {
return m_hStmt;
}

ODBCStmt(HDBC hDBCLink) {
SQLRETURN m_nReturn;
m_nReturn = SQLAllocHandle(SQL_HANDLE_STMT, hDBCLink, & m_hStmt);
SQLSetStmtAttr(m_hStmt, SQL_ATTR_CONCURRENCY,
(SQLPOINTER)SQL_CONCUR_ROWVER, 0);
SQLSetStmtAttr(m_hStmt, SQL_ATTR_CURSOR_TYPE,
(SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN, 0);
if(!IS_SQL_OK(m_nReturn))
m_hStmt = INVALID_HANDLE_VALUE;
}

virtual ~ODBCStmt() {
if(m_hStmt != INVALID_HANDLE_VALUE)
SQLFreeHandle(SQL_HANDLE_STMT, m_hStmt);
}

BOOL IsValid() {
return m_hStmt != INVALID_HANDLE_VALUE;
}

USHORT GetColumnCount() {
short nCols = 0;
if(!IS_SQL_OK(SQLNumResultCols(m_hStmt, & nCols)))
return 0;
return nCols;
}

DWORD GetChangedRowCount(void) {
long nRows = 0;
if(!IS_SQL_OK(SQLRowCount(m_hStmt, & nRows)))
return 0;
return nRows;
}

BOOL Query(LPCTSTR strSQL) {
SQLRETURN nRet = SQLExecDirect(m_hStmt, (SQLTCHAR *) strSQL, SQL_NTS);
return IS_SQL_OK(nRet);
}

BOOL Fetch() {
SQLRETURN nRet = SQLFetch(m_hStmt);
return IS_SQL_OK(nRet);
}

BOOL FecthRow(UINT nRow) {
return IS_SQL_OK(SQLSetPos(m_hStmt, nRow, SQL_POSITION,
SQL_LOCK_NO_CHANGE));
}

BOOL FetchPrevious() {
SQLRETURN nRet = SQLFetchScroll(m_hStmt, SQL_FETCH_PRIOR, 0);
return IS_SQL_OK(nRet);
}

BOOL FecthNext() {
SQLRETURN nRet = SQLFetchScroll(m_hStmt, SQL_FETCH_NEXT, 0);
return IS_SQL_OK(nRet);
}

BOOL FetchRow(ULONG nRow, BOOL Absolute = 1) {
SQLRETURN nRet =
SQLFetchScroll(m_hStmt, (Absolute ? SQL_FETCH_ABSOLUTE : SQL_FETCH_RELATIVE), nRow);
return IS_SQL_OK(nRet);
}

BOOL FetchFirst() {
SQLRETURN nRet = SQLFetchScroll(m_hStmt, SQL_FETCH_FIRST, 0);
return IS_SQL_OK(nRet);
}

BOOL FetchLast() {
SQLRETURN nRet = SQLFetchScroll(m_hStmt, SQL_FETCH_LAST, 0);
return IS_SQL_OK(nRet);
}

BOOL Cancel() {
SQLRETURN nRet = SQLCancel(m_hStmt);
return IS_SQL_OK(nRet);
}
};



//--
class ODBCRecord {
HSTMT m_hStmt;

public:
ODBCRecord(HSTMT hStmt) {
m_hStmt = hStmt;
};

~ODBCRecord() {
};

USHORT GetColumnCount() {
short nCols = 0;
if(!IS_SQL_OK(SQLNumResultCols(m_hStmt, & nCols)))
return 0;
return nCols;
}

BOOL BindColumn(USHORT Column, LPVOID pBuffer, ULONG pBufferSize,
LONG * pReturnedBufferSize = NULL, USHORT nType = SQL_C_TCHAR) {
LONG pReturnedSize = 0;
SQLRETURN Ret =
SQLBindCol(m_hStmt, Column, nType, pBuffer, pBufferSize,
& pReturnedSize);
if(* pReturnedBufferSize)
* pReturnedBufferSize = pReturnedSize;
return IS_SQL_OK(Ret);
}

USHORT GetColumnByName(LPCTSTR Column) {
SHORT nCols = GetColumnCount();
for(USHORT i = 1; i < (nCols + 1); i++) {
TCHAR Name[256] = _T("");
GetColumnName(i, Name, sizeof(Name));
if(!_tcsicmp(Name, Column))
return i;
}
return 0;
}

BOOL GetData(USHORT Column, LPVOID pBuffer, ULONG pBufLen, LONG * dataLen =
NULL, int Type = SQL_C_DEFAULT) {
SQLINTEGER od = 0;
int Err = SQLGetData(m_hStmt, Column, Type, pBuffer, pBufLen, & od);
if(IS_SQL_ERR(Err)) {
return 0;
}
if(dataLen)
* dataLen = od;
return 1;
}

int GetColumnType(USHORT Column) {
int nType = SQL_C_DEFAULT;
SQLTCHAR svColName[256] = _T("");
SWORD swCol = 0, swType = 0, swScale = 0, swNull = 0;
UDWORD pcbColDef;
SQLDescribeCol(m_hStmt, // Statement handle
Column, // ColumnNumber
svColName, // ColumnName
sizeof(svColName), // BufferLength
& swCol, // NameLengthPtr
& swType, // DataTypePtr
& pcbColDef, // ColumnSizePtr
& swScale, // DecimalDigitsPtr
& swNull); // NullablePtr
nType = (int)swType;
return (nType);
}

DWORD GetColumnSize(USHORT Column) {
int nType = SQL_C_DEFAULT;
SQLTCHAR svColName[256] = _T("");
SWORD swCol = 0, swType = 0, swScale = 0, swNull = 0;
DWORD pcbColDef = 0;
SQLDescribeCol(m_hStmt, // Statement handle
Column, // ColumnNumber
svColName, // ColumnName
sizeof(svColName), // BufferLength
& swCol, // NameLengthPtr
& swType, // DataTypePtr
& pcbColDef, // ColumnSizePtr
& swScale, // DecimalDigitsPtr
& swNull); // NullablePtr
return pcbColDef;
}

DWORD GetColumnScale(USHORT Column) {
int nType = SQL_C_DEFAULT;
SQLTCHAR svColName[256] = _T("");
SWORD swCol = 0, swType = 0, swScale = 0, swNull = 0;
DWORD pcbColDef = 0;
SQLDescribeCol(m_hStmt, // Statement handle
Column, // ColumnNumber
svColName, // ColumnName
sizeof(svColName), // BufferLength
& swCol, // NameLengthPtr
& swType, // DataTypePtr
& pcbColDef, // ColumnSizePtr
& swScale, // DecimalDigitsPtr
& swNull); // NullablePtr
return swScale;
}

BOOL GetColumnName(USHORT Column, LPTSTR Name, SHORT NameLen) {
int nType = SQL_C_DEFAULT;
SWORD swCol = 0, swType = 0, swScale = 0, swNull = 0;
DWORD pcbColDef = 0;
SQLRETURN Ret = SQLDescribeCol(m_hStmt, // Statement handle
Column, // ColumnNumber
(SQLTCHAR *) Name, // ColumnName
NameLen, // BufferLength
& swCol, // NameLengthPtr
& swType, // DataTypePtr
& pcbColDef, // ColumnSizePtr
& swScale, // DecimalDigitsPtr
& swNull); // NullablePtr
if(IS_SQL_ERR(Ret))
return 0;
return 1;
}

BOOL IsColumnNullable(USHORT Column) {
int nType = SQL_C_DEFAULT;
SQLTCHAR svColName[256] = _T("");
SWORD swCol = 0, swType = 0, swScale = 0, swNull = 0;
UDWORD pcbColDef;
SQLDescribeCol(m_hStmt, // Statement handle
Column, // ColumnNumber
svColName, // ColumnName
sizeof(svColName), // BufferLength
& swCol, // NameLengthPtr
& swType, // DataTypePtr
& pcbColDef, // ColumnSizePtr
& swScale, // DecimalDigitsPtr
& swNull); // NullablePtr
return (swNull == SQL_NULLABLE);
}
};
};


second PART:

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
#include <tchar.h>
#include "ODBCWrapper.cpp"
//make sure you include the namespace
using namespace std;
using namespace ODBC;

int main(void) {
MDBConnection link;
if(link.Connect("C:\\Documents and Settings\\Chester Mayle\\My Documents\\My Data Sources\\db1.mdb")) {
ODBCStmt Stmt(link);
SQLExecDirect(Stmt, (SQLTCHAR *) _T("USE Foo"), SQL_NTS);
int pos = 1;
TCHAR strQuery[256] = _T("SELECT [ ID1] FROM [\ID Data Base]\where ID='1234%'");
//t
//tl
//TCHAR strQuery[256] = _T("SELECT * FROM \ID Data Base\"");
//int nRet =
Stmt.Query(strQuery);
printf("%5d:\tColumns\t%d\r\n\r\n", Stmt.GetColumnCount(), 0);
string cg;
//SELECT [ID1] FROM [ID Data Base] where ID1='2%'";

while(Stmt.Fetch()) {
ODBCRecord rec(Stmt);
//printf("Row %5d\r\n", pos);

INT i = 0;
while(i < Stmt.GetColumnCount()) {
TCHAR Desc[512] = _T("");
SQLINTEGER cbDesc = 0;
rec.GetData(i=0, Desc, sizeof(Desc), & cbDesc);
//TCHAR Name[256] = _T("");
TCHAR Name[256] = _T( "WHERE ID1=2%");
rec.GetColumnName(i=0, Name, sizeof(Name));
i++;
printf("\t%15s\t\\>\t%25s\r\n", Name, Desc);

}
pos++;
};
}
else {
printf("Connection failed.");
}
link.Disconnect();
//getch();
char asd;
cin>> asd;
return 0;
}