static int odbc_dispatch2(void) { unsigned long retval; PWord rval; int rtype; PWord arg1; int type1; PWord arg2; int type2; PWord arg3; int type3; PWord arg4; int type4; PWord arg5; int type5; PWord arg6; int type6; PWord arg7; int type7; PWord arg8; int type8; PWord arg9; int type9; PI_getan(&arg1,&type1,1); if (type1 != PI_INT) if (!CI_get_integer((unsigned long *)&arg1,type1)) PI_FAIL; PI_getan(&arg2,&type2,2); if (type2 != PI_INT) if (!CI_get_integer((unsigned long *)&arg2,type2)) PI_FAIL; PI_getan(&arg3,&type3,3); if (type3 != PI_INT) if (!CI_get_integer((unsigned long *)&arg3,type3)) PI_FAIL; PI_getan(&arg4,&type4,4); if (type4 != PI_INT) if (!CI_get_integer((unsigned long *)&arg4,type4)) PI_FAIL; PI_getan(&arg5,&type5,5); if (type5 != PI_INT) if (!CI_get_integer((unsigned long *)&arg5,type5)) PI_FAIL; PI_getan(&arg6,&type6,6); if (type6 != PI_INT) if (!CI_get_integer((unsigned long *)&arg6,type6)) PI_FAIL; PI_getan(&arg7,&type7,7); if (type7 != PI_INT) if (!CI_get_integer((unsigned long *)&arg7,type7)) PI_FAIL; PI_getan(&arg8,&type8,8); if (type8 != PI_INT) if (!CI_get_integer((unsigned long *)&arg8,type8)) PI_FAIL; PI_getan(&arg9,&type9,9); switch(arg1) { case 0: retval = (unsigned long) SQLColAttributes(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLUSMALLINT ) arg4),((SQLPOINTER ) arg5),((SQLSMALLINT ) arg6),((SQLSMALLINT * ) arg7),((SQLINTEGER * ) arg8)); break; case 1: retval = (unsigned long) SQLGetDiagField(((SQLSMALLINT ) arg2),((SQLHANDLE ) arg3),((SQLSMALLINT ) arg4),((SQLSMALLINT ) arg5),((SQLPOINTER ) arg6),((SQLSMALLINT ) arg7),((SQLSMALLINT * ) arg8)); break; case 2: retval = (unsigned long) SQLColAttribute(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLUSMALLINT ) arg4),((SQLPOINTER ) arg5),((SQLSMALLINT ) arg6),((SQLSMALLINT * ) arg7),((SQLPOINTER ) arg8)); break; default: PI_FAIL; } PI_makedouble(&rval,&rtype,(double) retval); if (PI_unify(arg9,type9,rval,rtype)) PI_SUCCEED; PI_FAIL; }
static int do_stmt(Con& con, const char *sqlstr) { SQLHSTMT hstmt; SQLCHAR errmsg[256]; SQLCHAR colname[32]; SQLSMALLINT coltype; SQLSMALLINT colnamelen; SQLSMALLINT nullable; SQLUINTEGER collen[MAXCOLS]; SQLSMALLINT scale; SQLINTEGER outlen[MAXCOLS]; SQLCHAR *data[MAXCOLS]; SQLSMALLINT nresultcols = 0; SQLINTEGER rowcount; SQLINTEGER stmttype; SQLRETURN rc; /* allocate a statement handle */ SQLAllocHandle(SQL_HANDLE_STMT, con.hdbc, &hstmt); /* execute the SQL statement */ rc = SQLExecDirect(hstmt, (SQLCHAR*)sqlstr, SQL_NTS); if (rc == SQL_ERROR) { ndbout << "Operation failed" << endl; print_err(SQL_HANDLE_STMT, hstmt); return -1; } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO && rc != SQL_NO_DATA_FOUND) { ndbout << "Operation returned unknown code " << rc << endl; return -1; } /* see what kind of statement it was */ SQLGetDiagField(SQL_HANDLE_STMT, hstmt, 0, SQL_DIAG_DYNAMIC_FUNCTION_CODE, (SQLPOINTER)&stmttype, SQL_IS_INTEGER, (SQLSMALLINT *)NULL); switch (stmttype) { /* SELECT statement */ case SQL_DIAG_SELECT_CURSOR: /* determine number of result columns */ SQLNumResultCols(hstmt, &nresultcols); /*********************** * Display column names ***********************/ /* Print vertical divider */ printf("|"); for (int i=0; i<nresultcols; i++) { SQLDescribeCol(hstmt, i+1, colname, sizeof(colname), &colnamelen, &coltype, &collen[i], &scale, &nullable); collen[i] = display_length(coltype, collen[i], colname); for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-"); printf("--+"); } printf("\n"); printf("|"); for (int i=0; i<nresultcols; i++) { SQLDescribeCol(hstmt, i+1, colname, sizeof(colname), &colnamelen, &coltype, &collen[i], &scale, &nullable); /* assume there is a display_length function which computes correct length given the data type */ collen[i] = display_length(coltype, collen[i], colname); (void)printf(" %*.*s |", (int)collen[i], (int)collen[i], (char *)colname); /* allocate memory to bind column */ data[i] = (SQLCHAR *) malloc(collen[i]); if (data[i] == NULL) { ndbout << "Failed to allocate malloc memory in NDB SQL program" << endl; exit(-1); } /* bind columns to program vars, converting all types to CHAR */ SQLBindCol(hstmt, i+1, SQL_C_CHAR, data[i], collen[i], &outlen[i]); } printf("\n"); /* Print vertical divider */ printf("|"); for (int i=0; i<nresultcols; i++) { SQLDescribeCol(hstmt, i+1, colname, sizeof(colname), &colnamelen, &coltype, &collen[i], &scale, &nullable); collen[i] = display_length(coltype, collen[i], colname); for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-"); printf("--+"); } printf("\n"); /********************** * Display result rows **********************/ { int no_of_rows_fetched=0; while (1) { rc=SQLFetch(hstmt); errmsg[0] = '\0'; if (rc == SQL_ERROR) { print_err(SQL_HANDLE_STMT, hstmt); break; } if (rc == SQL_NO_DATA) break; if (rc == SQL_SUCCESS) { printf("|"); for (int i=0; i<nresultcols; i++) { if (outlen[i] == SQL_NULL_DATA || outlen[i] >= (SQLINTEGER) collen[i]) build_indicator_message(errmsg, (SQLPOINTER *)data[i], collen[i], &outlen[i], i); (void)printf(" %*.*s |", (int)collen[i], (int)collen[i], (char *)data[i]); } /* print any truncation messages */ (void)printf("\n%s", (char *)errmsg); } else if (rc == SQL_SUCCESS_WITH_INFO) { printf("|"); for (int i=0; i<nresultcols; i++) { if (outlen[i] == SQL_NULL_DATA || outlen[i] >= (SQLINTEGER) collen[i]) build_indicator_message(errmsg, (SQLPOINTER *)data[i], collen[i], &outlen[i], i); (void)printf(" %*.*s |", (int)collen[i], (int)collen[i], (char *)data[i]); } /* for all columns in this row */ /* print any truncation messages */ (void)printf("\n%s", (char *)errmsg); } no_of_rows_fetched++; } /* while rows to fetch */ /* Print vertical divider */ printf("|"); for (int i=0; i<nresultcols; i++) { SQLDescribeCol(hstmt, i+1, colname, sizeof(colname), &colnamelen, &coltype, &collen[i], &scale, &nullable); collen[i] = display_length(coltype, collen[i], colname); for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-"); printf("--+"); } printf("\n"); ndbout << no_of_rows_fetched << " rows fetched" << endl; } SQLCloseCursor(hstmt); break; /* searched DELETE, INSERT or searched UPDATE statement */ case SQL_DIAG_DELETE_WHERE: case SQL_DIAG_INSERT: case SQL_DIAG_UPDATE_WHERE: /* check rowcount */ SQLRowCount(hstmt, (SQLINTEGER*)&rowcount); ndbout << (int)rowcount << " rows affected" << endl; break; /* other statements */ case SQL_DIAG_ALTER_TABLE: case SQL_DIAG_CREATE_TABLE: case SQL_DIAG_CREATE_VIEW: case SQL_DIAG_DROP_TABLE: case SQL_DIAG_DROP_VIEW: case SQL_DIAG_CREATE_INDEX: case SQL_DIAG_DROP_INDEX: case SQL_DIAG_DYNAMIC_DELETE_CURSOR: case SQL_DIAG_DYNAMIC_UPDATE_CURSOR: case SQL_DIAG_GRANT: case SQL_DIAG_REVOKE: ndbout << "Operation successful" << endl; break; /* implementation-defined statement */ default: (void)printf("Unknown Statement type=%ld\n", stmttype); break; } /* free data buffers */ for (int i=0; i<nresultcols; i++) { (void)free(data[i]); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt); // free statement handle return(0); }
static int get_error_from_diag_rec( odbcdr_context_def *context, SQLSMALLINT handle_type, SQLHANDLE handle) { int rdbi_status = RDBI_SUCCESS; int crit_err_found = FALSE; RETCODE rec_retcode = SQL_SUCCESS; RETCODE field_retcode = SQL_SUCCESS; SQLWCHAR szSqlState[ODBCDR_MAX_BUFF_SIZE]; SQLWCHAR szErrorMsg[ODBCDR_MAX_BUFF_SIZE]; SDWORD pfNativeError = 0L; SWORD pcbErrorMsg = 0; SQLSMALLINT cRecNmbr = 1; SDWORD SS_Severity = 0; SQLINTEGER Rownumber = 0; SQLINTEGER Colnumber = 0; szSqlState[0] = L'\0'; szErrorMsg[0] = L'\0'; /* ** Loop through the diagnostic records until there are no records ** left or a critical error is found. ** For now, we will only deal with the first critical error, and ** ignore the rest. */ while ((rec_retcode != SQL_NO_DATA_FOUND) && !crit_err_found) { rec_retcode = (context->odbcdr_UseUnicode) ? SQLGetDiagRecW(handle_type, handle, cRecNmbr, szSqlState, &pfNativeError, szErrorMsg, ODBCDR_MAX_BUFF_SIZE, &pcbErrorMsg) : SQLGetDiagRec(handle_type, handle, cRecNmbr, (SQLCHAR*)szSqlState, &pfNativeError, (SQLCHAR*)szErrorMsg, ODBCDR_MAX_BUFF_SIZE, &pcbErrorMsg); if (rec_retcode != SQL_NO_DATA_FOUND) { field_retcode = (context->odbcdr_UseUnicode) ? SQLGetDiagFieldW( handle_type, handle, cRecNmbr, SQL_DIAG_ROW_NUMBER, &Rownumber, SQL_IS_INTEGER, NULL) : SQLGetDiagField( handle_type, handle, cRecNmbr, SQL_DIAG_ROW_NUMBER, &Rownumber, SQL_IS_INTEGER, NULL); if (Rownumber != SQL_NO_ROW_NUMBER && Rownumber != SQL_ROW_NUMBER_UNKNOWN) { field_retcode = (context->odbcdr_UseUnicode) ? SQLGetDiagFieldW( handle_type, handle, cRecNmbr, SQL_DIAG_COLUMN_NUMBER , &Colnumber, SQL_IS_INTEGER, NULL) : SQLGetDiagField( handle_type, handle, cRecNmbr, SQL_DIAG_COLUMN_NUMBER , &Colnumber, SQL_IS_INTEGER, NULL); } #ifdef _WIN32 field_retcode = (context->odbcdr_UseUnicode) ? SQLGetDiagFieldW( handle_type, handle, cRecNmbr, SQL_DIAG_SS_SEVERITY, &SS_Severity, SQL_IS_INTEGER, NULL): SQLGetDiagField(handle_type, handle, cRecNmbr, SQL_DIAG_SS_SEVERITY, &SS_Severity, SQL_IS_INTEGER,NULL); #endif switch( pfNativeError ) { case 208 : rdbi_status = RDBI_NO_SUCH_TABLE; crit_err_found = TRUE; break; case 916 : rdbi_status = RDBI_NOT_VALID_USER_IN_DATABASE; crit_err_found = TRUE; break; case 1555 : rdbi_status = RDBI_RESOURCE_BUSY; crit_err_found = TRUE; break; case 18456 : rdbi_status = RDBI_INVLD_USER_PSWD; crit_err_found = TRUE; break; case 913: // "Could not find database ID 52. Database may not be activated yet or may be in transition." // Severity 16. This is rather a bug related to updating views. rdbi_status = RDBI_GENERIC_ERROR; break; case 2601: case 2627: // Duplicate index found. rdbi_status = RDBI_DUPLICATE_INDEX; crit_err_found = TRUE; break; case 2714: // There is already an object named '%.*ls' in the database. rdbi_status = RDBI_OBJECT_EXISTS; crit_err_found = TRUE; break; case 3701: // No such object rdbi_status = RDBI_NO_SUCH_TABLE; crit_err_found = TRUE; break; case 229: // insufficient privileges rdbi_status = RDBI_INSUFFICIENT_PRIVS; crit_err_found = TRUE; break; default : // If we did not identify any specific errors in the // diagnostic record, use the severity level to // determine if a error occurred // *** DS doesn't agree. //if (SS_Severity > 10) { rdbi_status = RDBI_GENERIC_ERROR; crit_err_found = TRUE; //} else { // rdbi_status = RDBI_SUCCESS; //} } //switch cRecNmbr++; //Increment to next diagnostic record. } //if plm_retcode } // End while. if (context->odbcdr_UseUnicode) save_err_msgW( context, handle_type, handle, 1); // 1 = assuming a connection has already been made else save_err_msg( context, handle_type, handle, 1); // 1 = assuming a connection has already been made return rdbi_status; }
static void save_err_msg( odbcdr_context_def *context, SQLSMALLINT plm_handle_type, // Handle type SQLHANDLE plm_handle, // Handle name int ConnInd) // Connection indicator { RETCODE plm_retcode = SQL_SUCCESS; UCHAR plm_szSqlState[ODBCDR_MAX_BUFF_SIZE]; UCHAR plm_szErrorMsg[ODBCDR_MAX_BUFF_SIZE]; SDWORD plm_pfNativeError = 0L; SWORD plm_pcbErrorMsg = 0; SQLSMALLINT plm_cRecNmbr = 1; SDWORD plm_SS_MsgState = 0; SDWORD plm_SS_Severity = 0; SQLINTEGER plm_Rownumber = 0; USHORT plm_SS_Line; SQLSMALLINT plm_cbSS_Procname, plm_cbSS_Srvname; SQLCHAR plm_SS_Procname[555]; SQLCHAR plm_SS_Srvname[555]; plm_szSqlState[0] = '\0'; plm_szSqlState[0] = '\0'; debug_on("odbcdr_xlt_status: save_err_msg"); context->odbcdr_last_err_msg[0] = '\0'; while (plm_retcode != SQL_NO_DATA_FOUND) { plm_retcode = SQLGetDiagRec(plm_handle_type, plm_handle, plm_cRecNmbr, plm_szSqlState, &plm_pfNativeError, plm_szErrorMsg, ODBCDR_MAX_BUFF_SIZE - 1, &plm_pcbErrorMsg); // Note that if the application has not yet made a // successful connection, the SQLGetDiagField // information has not yet been cached by ODBC // Driver Manager and these calls to SQLGetDiagField // will fail. if (plm_retcode != SQL_NO_DATA_FOUND) { if (ConnInd) { plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_ROW_NUMBER, &plm_Rownumber, SQL_IS_INTEGER, NULL); #ifdef _WIN32 plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_SS_LINE, &plm_SS_Line, SQL_IS_INTEGER, NULL); plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_SS_MSGSTATE, &plm_SS_MsgState, SQL_IS_INTEGER, NULL); plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_SS_SEVERITY, &plm_SS_Severity, SQL_IS_INTEGER, NULL); plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_SS_PROCNAME, &plm_SS_Procname, sizeof(plm_SS_Procname), &plm_cbSS_Procname); plm_retcode = SQLGetDiagField( plm_handle_type, plm_handle, plm_cRecNmbr, SQL_DIAG_SS_SRVNAME, &plm_SS_Srvname, sizeof(plm_SS_Srvname), &plm_cbSS_Srvname); #endif } // if ConnInd // display error messages, filtering out expected "errors" if ((plm_pfNativeError == 5701) || // Change database context error code (plm_pfNativeError == 5703) ) { // Change language setting error code break;// out of while loop, do not display error messages } else { // Save the message. strcpy( context->odbcdr_last_err_msg, (char*)plm_szErrorMsg ); debug1("szSqlState = %s",plm_szSqlState); debug1("pfNativeError = %d",plm_pfNativeError); debug1("szErrorMsg = %s",plm_szErrorMsg); debug1("pcbErrorMsg = %d",plm_pcbErrorMsg); if (ConnInd) { debug1("ODBCRowNumber = %d", plm_Rownumber); debug1("SSrvrLine = %d", plm_Rownumber); debug1("SSrvrMsgState = %d",plm_SS_MsgState); debug1("SSrvrSeverity = %d",plm_SS_Severity); debug1("SSrvrProcname = %s",plm_SS_Procname); debug1("SSrvrSrvname = %s",plm_SS_Srvname); } break; } //else } //if plm_retcode plm_cRecNmbr++; //Increment to next diagnostic record. } // End while. debug_return_void(NULL); }
bool CODBCObjectBase::Refresh_Error_Status( SQLRETURN error_code ) { FATAL_ASSERT( EnvironmentHandle != 0 ); Errors.clear(); BadRowNumber = -1; if ( error_code == SQL_SUCCESS ) { ErrorState = DBEST_SUCCESS; return true; } else if ( error_code == SQL_INVALID_HANDLE ) { ErrorState = DBEST_FATAL_ERROR; return true; } SQLSMALLINT handle_type = SQL_HANDLE_ENV; SQLHANDLE handle = EnvironmentHandle; if ( StatementHandle != 0 ) { handle_type = SQL_HANDLE_STMT; handle = StatementHandle; } else if ( ConnectionHandle != 0 ) { handle_type = SQL_HANDLE_DBC; handle = ConnectionHandle; } SQLINTEGER record_count = 0; SQLRETURN ec = SQLGetDiagField( handle_type, handle, 0, SQL_DIAG_NUMBER, &record_count, SQL_IS_INTEGER, NULL ); FATAL_ASSERT( ec == SQL_SUCCESS ); SQLWCHAR sql_state[ 6 ] = { 0 }; SQLINTEGER sql_error_code = 0; SQLSMALLINT text_length = 0; SQLWCHAR error_buffer[ 1024 ] = { 0 }; for ( SQLSMALLINT i = 1; i <= record_count; ++i ) { ec = SQLGetDiagRec( handle_type, handle, i, sql_state, &sql_error_code, error_buffer, sizeof( error_buffer ) / sizeof( SQLWCHAR ), &text_length ); FATAL_ASSERT( ec == SQL_SUCCESS ); Errors.push_back( SODBCError( sql_error_code, sql_state, std::wstring( error_buffer ) ) ); if ( handle_type == SQL_HANDLE_STMT && BadRowNumber == -1 ) { SQLLEN bad_row = 0; ec = SQLGetDiagField( handle_type, handle, i, SQL_DIAG_ROW_NUMBER, &bad_row, SQL_IS_INTEGER, NULL ); FATAL_ASSERT( ec == SQL_SUCCESS ); if ( bad_row >= 1 ) { BadRowNumber = static_cast< int32_t >( bad_row - 1 ); } } } return false; }