DB2 9 应用开发（733 考试）认证指南，第 5 部分: CLI/ODBC 编程(5)-sdccf-ChinaUnix博客

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265717) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265716) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265715) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265714) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265713) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265712) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265711) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265710) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265709) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265708) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265707) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265706) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265705) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265704) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265703) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265702) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265701) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265700) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265699) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265698) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265697) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265696) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265695) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265694) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265693) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265692) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265691) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265690) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265689) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265688) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265687) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265686) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265685) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265684) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265683) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265682) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265681) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265680) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

诊断和错误处理

返回码	意义
`SQL_SUCCESS`	CLI/ODBC 函数成功完成
`SQL_SUCCESS_WITH_INFO`	CLI/ODBC 函数成功完成，但是遇到一个警告或非致命错误
`SQL_NO_DATA` or `SQL_NO_DATA_FOUND`	CLI/ODBC 函数成功完成，但是未找到相关的数据
`SQL_INVALID_HANDLE`	由于指定了无效的环境句柄、连接句柄、语句句柄或描述符句柄，CLI/ODBC 函数失败。只有在指定的句柄还没有分配空间，或者类型不对的情况下（例如，当期望的是一个环境句柄时，提供的却是一个连接句柄），才会返回该返回码
`SQL_NEED_DATA`	由于函数没有找到期望在执行时使用的数据，CLI/ODBC 函数失败。当返回该返回码时，通常是因为参数或列已经被绑定为实时数据的（`SQL_DATA_AT_EXEC`）参数/列
`SQL_STILL_EXECUTING`	异步启动的 CLI/ODBC 函数仍然在执行
`SQL_ERROR`	CLI/ODBC 函数失败

回页首

                     
#include 
#include 
#include 

int main()
{
    // Declare The Local Memory Variables
    SQLHANDLE    EnvHandle = 0;
    SQLHANDLE    ConHandle = 0;
    SQLHANDLE    StmtHandle = 0;
    SQLCHAR      ConString[512];
    SQLRETURN    RetCode = SQL_SUCCESS;

    SQLSMALLINT  Counter = 0;
    SQLINTEGER   NumRecords = 0;
    SQLINTEGER   NativeErr = 0;
    SQLCHAR      SQLState[6];
    SQLCHAR      ErrMsg[255];
    SQLSMALLINT  ErrMsgLen = 0;
    SQLCHAR      SQLStmt[255];

    // Allocate An Environment Handle
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
        &EnvHandle);

    // Set The ODBC 应用程序 Version To 3.x
    if (EnvHandle != 0)
        SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION, 
            (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER);

    // Allocate A Connection Handle
    if (EnvHandle != 0)
        SQLAllocHandle(SQL_HANDLE_DBC, EnvHandle,
            &ConHandle);

    // Build A Valid Connection String
    sprintf((char *) ConString, "driver={IBM DB2 ODBC DRIVER};");
    strcat((char *) ConString, "dbalias=sample;uid=db2admin;pwd=ibmdb2");

    // Connect To The Appropriate Data Source
    if (ConHandle != 0)
        RetCode = SQLDriverConnect(ConHandle, NULL, (SQLCHAR *) ConString,
                      SQL_NTS, NULL, 0, NULL, 
                      SQL_DRIVER_NOPROMPT);

    // If Unable To Establish A Data Source Connection,
    // Obtain Any Diagnostic Information Available
    if (RetCode != SQL_SUCCESS)
    {
        // Find Out How Many Diagnostic Records Are 
        // Available
        SQLGetDiagField(SQL_HANDLE_DBC, ConHandle, 0,
            SQL_DIAG_NUMBER, &NumRecords, SQL_IS_INTEGER,
            NULL);

        // Retrieve And Display The Diagnostic Information
        // Produced 
        for (Counter = 1; Counter <= NumRecords; Counter++)
        {
            // Retrieve The Information Stored In Each
            // Diagnostic Record Generated 
            SQLGetDiagRec(SQL_HANDLE_DBC, ConHandle, Counter,
                SQLState, &NativeErr, ErrMsg, sizeof(ErrMsg),
                &ErrMsgLen);

            // Display The Information Retrieved
            printf("SQLSTATE : %s\n", SQLState);
            printf("%s\n", ErrMsg);

            // Prepare To Exit
            goto EXIT;            
        }
    }

    // Allocate An SQL Statement Handle
    if (ConHandle != 0)
        SQLAllocHandle(SQL_HANDLE_STMT, ConHandle,
           &StmtHandle);

    // Set The Appropriate Statement Attributes
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_DEFERRED_PREPARE, 
        (SQLPOINTER) SQL_DEFERRED_PREPARE_OFF, 0);
    SQLSetStmtAttr(StmtHandle, SQL_ATTR_CURSOR_TYPE, 
        (SQLPOINTER) SQL_CURSOR_STATIC, 0);

    // Define A SELECT SQL Statement
    strcpy((char *) SQLStmt, "SELECT deptno, deptname FROM ");
    strcat((char *) SQLStmt, "department");

    // Prepare The SQL Statement
    if (SQLPrepare(StmtHandle, (SQLCHAR *) SQLStmt, SQL_NTS) == SQL_SUCCESS)
        {
            // Obtain The Estimated Number Of Rows That Will Be
            // Returned By The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords, 
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
            printf("Estimated number of records that will be returned : %d\n", 
                NumRecords);
     
            // Execute The SELECT SQL Statement
            SQLExecute(StmtHandle);

            // Obtain The Actual Number Of Rows Returned By 
            // The SELECT Statement
            RetCode = SQLGetDiagField(SQL_HANDLE_STMT, StmtHandle, 0, 
                          SQL_DIAG_CURSOR_ROW_COUNT, &NumRecords,
                          SQL_IS_INTEGER, NULL);

            // Display The Information Retrieved
            if (RetCode == SQL_SUCCESS)
                printf("Actual number of records returned : %d\n",
                    NumRecords);
	}

EXIT:

    // Free The SQL Statement Handle
    if (StmtHandle != 0)
        SQLFreeHandle(SQL_HANDLE_STMT, StmtHandle);

    // Free The Connection Handle
    if (ConHandle != 0)
        SQLFreeHandle(SQL_HANDLE_DBC, ConHandle);

    // Free The Environment Handle
    if (EnvHandle != 0)
        SQLFreeHandle(SQL_HANDLE_ENV, EnvHandle);

    // Return Control To The Operating System
    return(0);
}

阅读(265679) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们