TestODBC

#include <stdio.h>
#include <windows.h> // for sqlext.h
#include <sqlext.h> // link against libodbc32.a

static void ShowErrMsgODBC(const char* szFuncName, SQLRETURN retcode, SQLSMALLINT type, SQLHANDLE handle)
{
    // #define SQL_ERROR (-1)
    // #define SQL_SUCCESS_WITH_INFO 1
    if ( SQL_SUCCESS != retcode )
    {
        printf("%s:[retcode = 0x%x]\n", szFuncName, retcode);

        char bufSQLState[512];
        int iNativeErrorPtr = 0;
        char bufMessageText[512];
        int iBufferLength = 512;
        int iTextLengthPtr = 0;

        SQLGetDiagRec( type,
                       handle,
                       1,
                       (SQLCHAR*)bufSQLState,
                       (SQLINTEGER*)&iNativeErrorPtr,
                       (SQLCHAR*)bufMessageText,
                       iBufferLength,
                       (SQLSMALLINT*)&iTextLengthPtr );

        printf("-----------------------------------\n");
        printf("ShowErrMsgODBC:[%s] [%d]\n[%s] [%d]\n",
               bufSQLState,iNativeErrorPtr,bufMessageText,iTextLengthPtr);
        printf("-----------------------------------\n");
    }
}

static void PrintAllODBC(SQLHSTMT hstmt)
{
    char szData0[255];
    char szData1[255];
    char szData2[255];
    SQLLEN bytes0;
    SQLLEN bytes1;
    SQLLEN bytes2;

    printf("---------------- (PrintAllODBC begin) ----------------\n");
    while ( SQL_SUCCESS == SQLFetch(hstmt) ) // SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 0)
    {
        SQLGetData(hstmt, 1, SQL_C_CHAR, szData0, sizeof(szData0), &bytes0);
        SQLGetData(hstmt, 2, SQL_C_CHAR, szData1, sizeof(szData1), &bytes1);
        SQLGetData(hstmt, 3, SQL_C_CHAR, szData2, sizeof(szData2), &bytes2);

        printf("data: [%-10s] [%-10s] [%-10s]\n", szData0,szData1,szData2);
        //printf("len: [%d] [%d] [%d]\n\n", bytes0,bytes1,bytes2);
    }
    printf("---------------- (PrintAllODBC end) ----------------\n\n");
}

static void PrintAllODBC2(SQLHSTMT hstmt)
{
    char szData0[255];
    char szData1[255];
    char szData2[255];

    SQLBindCol(hstmt, 1, SQL_C_CHAR, szData0, sizeof(szData0), NULL);
    SQLBindCol(hstmt, 2, SQL_C_CHAR, szData1, sizeof(szData1), NULL);
    SQLBindCol(hstmt, 3, SQL_C_CHAR, szData2, sizeof(szData2), NULL);

    while ( SQL_SUCCESS == SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 0) )
    {
        printf("data2:[%s][%s][%s]\n", szData0,szData1,szData2);
    }
}

static void PrintOneODBC(SQLHSTMT hstmt, int iIndex)
{
    char szData0[255];
    char szData1[255];
    char szData2[255];

    if ( SQL_SUCCESS == SQLFetchScroll(hstmt, SQL_FETCH_ABSOLUTE, iIndex) )
    {
        SQLGetData(hstmt, 1, SQL_C_CHAR, szData0, sizeof(szData0), NULL);
        SQLGetData(hstmt, 2, SQL_C_CHAR, szData1, sizeof(szData1), NULL);
        SQLGetData(hstmt, 3, SQL_C_CHAR, szData2, sizeof(szData2), NULL);

        printf("data: [%s] [%s] [%s]\n", szData0,szData1,szData2);
    }
}

static void TestODBC()
{
    const char* szServerName = "test_mysql"; // Data source name.
    const char* szStatementText = "select * from test"; // SQL statement to be executed.

    SQLHENV henv = NULL;
    SQLHDBC hdbc = NULL;
    SQLHSTMT hstmt = NULL;

    SQLRETURN retcode = SQL_ERROR;

    retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
    ShowErrMsgODBC("SQLAllocHandle::SQL_HANDLE_ENV", retcode, SQL_HANDLE_ENV, henv);
    retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
    ShowErrMsgODBC("SQLSetEnvAttr::SQL_ATTR_ODBC_VERSION", retcode, SQL_HANDLE_ENV, henv);

    retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
    ShowErrMsgODBC("SQLAllocHandle::SQL_HANDLE_DBC", retcode, SQL_HANDLE_DBC, hdbc);
    retcode = SQLSetConnectAttr(hdbc, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)0, 0);
    ShowErrMsgODBC("SQLSetConnectAttr::SQL_ATTR_CONNECTION_TIMEOUT", retcode, SQL_HANDLE_DBC, hdbc);
    retcode = SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)3, 0);
    ShowErrMsgODBC("SQLSetConnectAttr::SQL_LOGIN_TIMEOUT", retcode, SQL_HANDLE_DBC, hdbc);

    retcode = SQLConnect(hdbc, (SQLCHAR*)szServerName, SQL_NTS, NULL, 0, NULL, 0);
    ShowErrMsgODBC("SQLConnect", retcode, SQL_HANDLE_DBC, hdbc);

    retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
    ShowErrMsgODBC("SQLAllocHandle::SQL_HANDLE_STMT", retcode, SQL_HANDLE_STMT, hstmt);
    //retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER)SQL_CURSOR_DYNAMIC, 0);
    //ShowErrMsgODBC("SQLSetStmtAttr::SQL_ATTR_CURSOR_TYPE", retcode, SQL_HANDLE_STMT, hstmt);
    retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER)SQL_SCROLLABLE, 0);
    ShowErrMsgODBC("SQLSetStmtAttr::SQL_ATTR_CURSOR_SCROLLABLE", retcode, SQL_HANDLE_STMT, hstmt);
    retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER)0, 0);
    ShowErrMsgODBC("SQLSetStmtAttr::SQL_ATTR_QUERY_TIMEOUT", retcode, SQL_HANDLE_STMT, hstmt);

    if ( SQL_SUCCESS == SQLExecDirect(hstmt, (SQLCHAR*)szStatementText, SQL_NTS) )
    {
        SQLSMALLINT col_count = 0;
        SQLNumResultCols(hstmt, &col_count);
        printf("info:[SQLNumResultCols = %d]\n", col_count);
        SQLLEN row_count = 0;
        SQLRowCount(hstmt, &row_count);
        printf("info:[SQLRowCount = %d]\n", (int)row_count);

        char szColumnName0[32];
        char szColumnName1[32];
        char szColumnName2[32];
        SQLDescribeCol(hstmt, 1, (SQLCHAR*)szColumnName0, sizeof(szColumnName0), NULL, NULL, NULL, NULL, NULL);
        SQLDescribeCol(hstmt, 2, (SQLCHAR*)szColumnName1, sizeof(szColumnName1), NULL, NULL, NULL, NULL, NULL);
        SQLDescribeCol(hstmt, 3, (SQLCHAR*)szColumnName2, sizeof(szColumnName2), NULL, NULL, NULL, NULL, NULL);
        printf("Col_Name:(%s)(%s)(%s)\n\n", szColumnName0,szColumnName1,szColumnName2);

        //PrintAllODBC(hstmt);
        PrintAllODBC2(hstmt);

        PrintOneODBC(hstmt, 3);
        PrintOneODBC(hstmt, 2);
        PrintOneODBC(hstmt, 4);
    }

    //retcode = SQLCancel(hstmt);
    //ShowErrMsgODBC("SQLCancel", retcode, SQL_HANDLE_STMT, hstmt);

    retcode = SQLCloseCursor(hstmt);
    ShowErrMsgODBC("SQLCloseCursor", retcode, SQL_HANDLE_STMT, hstmt);

    retcode = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
    ShowErrMsgODBC("SQLFreeHandle::SQL_HANDLE_STMT", retcode, SQL_HANDLE_STMT, hstmt);
    retcode = SQLDisconnect(hdbc);
    ShowErrMsgODBC("SQLDisconnect", retcode, SQL_HANDLE_DBC, hdbc);
    retcode = SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
    ShowErrMsgODBC("SQLFreeHandle::SQL_HANDLE_DBC", retcode, SQL_HANDLE_DBC, hdbc);
    retcode = SQLFreeHandle(SQL_HANDLE_ENV, henv);
    ShowErrMsgODBC("SQLFreeHandle::SQL_HANDLE_ENV", retcode, SQL_HANDLE_ENV, henv);
}

int main(void)
{
    TestODBC();
    return 0;
}