| /**********************************************************************
|
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| ********************************************************************/
|
| /**************************************************************************
|
| **************************************************************************/
|
| //
|
| //
|
| #include "CDiag.h"
|
| #include "DrvrGlobal.h"
|
| #include "CConnect.h"
|
| #include "tdm_odbcDrvMsg.h"
|
| #include "DrvrSrvr.h"
|
| #include "diagfunctions.h"
|
|
|
| #include <algorithm>
|
| #define GETDIAGRECPTR(ret, multiset, index) { CDIAGDEQUE::iterator i = multiset.begin(); advance (i, index); ret = *i; }
|
|
|
| DIAG_FUNC_MAP diagFuncMap[] = {
|
| {"SQL_DIAG_UNKNOWN_STATEMENT", SQL_DIAG_UNKNOWN_STATEMENT},
|
| {NULL}
|
| };
|
|
|
| // This should be in sync with ERROR_COMPONENT in drvrGlobal.h
|
| char *gErrorMsgHeader[] =
|
| {
|
| "[TRAF][Trafodion ODBC Driver]",
|
| "[TRAF][Trafodion ODBC Driver][DCS Server]",
|
| "[TRAF][Trafodion ODBC Driver][Network Component]",
|
| "[TRAF][Trafodion ODBC Driver][Trafodion Database]",
|
| "[TRAF][Trafodion ODBC Driver][DCS Services]",
|
| "[TRAF][Trafodion ODBC Driver][DCS Cfg Server]"
|
| };
|
|
|
|
|
| // Implementation for the member functions of CDiagRec
|
| CDiagStatus::CDiagStatus(short diagComponentCode,
|
| DWORD diagErrorCode,
|
| SQLINTEGER diagNative,
|
| char *diagMessageText,
|
| char *diagSqlState,
|
| SQLLEN diagRowNumber,
|
| SQLINTEGER diagColumnNumber,
|
| short diagNoParams,
|
| va_list diagParams)
|
| {
|
| short i;
|
|
|
| m_DiagComponentCode = diagComponentCode;
|
| m_DiagErrorCode = diagErrorCode;
|
| m_DiagRowNumber = diagRowNumber;
|
| m_DiagColumnNumber = diagColumnNumber;
|
| m_DiagNative = diagNative;
|
| if (diagMessageText != NULL)
|
| m_DiagMessageText = (char *)diagMessageText;
|
| else
|
| m_DiagMessageText = DIAG_EMPTY_STRING;
|
| for (i = 0; i < MAX_DIAG_PARAMS && i < diagNoParams ; i++)
|
| m_DiagParams[i] = va_arg(diagParams, char *);
|
| for (;i < MAX_DIAG_PARAMS ; i++)
|
| m_DiagParams[i] = DIAG_EMPTY_STRING;
|
| if (diagSqlState != NULL)
|
| strncpy((char *)m_DiagSqlState, diagSqlState,6);
|
| else
|
| m_DiagSqlState[0] = '\0';
|
| }
|
|
|
|
|
| // Implementation for the member functions of CDiagRec
|
|
|
| CDiagRec::CDiagRec()
|
| {
|
| m_DiagCursorRowCount = -1;
|
| m_DiagRowCount = -1;
|
| m_DiagDynamicFuncCode = SQL_DIAG_UNKNOWN_STATEMENT;
|
| }
|
|
|
| CDiagRec::~CDiagRec()
|
| {
|
| clear();
|
| }
|
|
|
| void CDiagRec::clear()
|
| {
|
| CDIAGDEQUE::iterator i, temp; /*AMR*/
|
|
|
| i=m_DiagStatusCollect.begin();
|
| unsigned long count=m_DiagStatusCollect.size();
|
|
|
| while(count>0 && !m_DiagStatusCollect.empty())
|
| {
|
| temp = i;
|
| i++;
|
| if(*temp)delete *temp;
|
| m_DiagStatusCollect.erase(temp);
|
| }
|
| m_DiagDynamicFuncCode = 0;
|
| }
|
|
|
|
|
| void CDiagRec::setDiagRec(short diagComponentCode,
|
| DWORD diagErrorCode,
|
| SQLINTEGER diagNative,
|
| char *diagMessageText,
|
| char *diagSqlState,
|
| SQLLEN diagRowNumber,
|
| SQLINTEGER diagColumnNumber,
|
| short diagNoParams,
|
| va_list diagParams)
|
| {
|
| CDiagStatusPtr diagStatus;
|
|
|
| diagStatus = new CDiagStatus(diagComponentCode, diagErrorCode, diagNative, diagMessageText,
|
| diagSqlState, diagRowNumber, diagColumnNumber, diagNoParams, diagParams);
|
| if (diagStatus != NULL)
|
| {
|
| CDIAGDEQUE::iterator iterHint = m_DiagStatusCollect.end();
|
| m_DiagStatusCollect.insert(iterHint,diagStatus);
|
| }
|
| }
|
|
|
| void CDiagRec::setDiagRec(short diagComponentCode,
|
| DWORD diagErrorCode,
|
| SQLINTEGER diagNative,
|
| char *diagMessageText,
|
| char *diagSqlState,
|
| SQLLEN diagRowNumber,
|
| SQLINTEGER diagColumnNumber,
|
| short diagNoParams,...)
|
| {
|
| va_list marker;
|
|
|
| va_start( marker, diagNoParams);
|
|
|
| setDiagRec(diagComponentCode, diagErrorCode, diagNative,
|
| diagMessageText, diagSqlState, diagRowNumber, diagColumnNumber, diagNoParams, marker);
|
| }
|
|
|
| void CDiagRec::setDiagRec(const odbc_SQLSvc_SQLError *SQLError)
|
| {
|
|
|
| IDL_unsigned_long curErrorNo;
|
| ERROR_DESC_def *error_desc_def;
|
|
|
| for (curErrorNo = 0, error_desc_def = SQLError->errorList._buffer;
|
| curErrorNo < SQLError->errorList._length ; curErrorNo++, error_desc_def++)
|
| {
|
|
|
| if( error_desc_def->errorCodeType == SQLERRWARN && error_desc_def->sqlcode == 0 && error_desc_def->errorText == NULL )
|
| continue;
|
|
|
| // Resource Governing
|
| if (error_desc_def->errorCodeType == ESTIMATEDCOSTRGERRWARN)
|
| {
|
| // Actual value: error_desc_def->Param4
|
| // Limit: error_desc_def->Param2
|
| setDiagRec(SERVER_ERROR, IDS_S1_000_07, ESTIMATEDCOSTRGERRWARN, NULL, NULL,
|
| SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 2,
|
| error_desc_def->Param4, error_desc_def->Param2);
|
|
|
| }
|
| else if (error_desc_def->errorCodeType == INFOSTATSERR || error_desc_def->errorCodeType == CONFIGERR)
|
| {
|
| // Infostats and CONFIG cmd
|
| setDiagRec(SERVER_ERROR, IDS_HY_000, error_desc_def->sqlcode, error_desc_def->errorText,
|
| error_desc_def->sqlstate);
|
| }
|
| else if(error_desc_def->sqlcode == SQL_PASSWORD_EXPIRING || error_desc_def->sqlcode == SQL_PASSWORD_GRACEPERIOD)
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_WARNING, error_desc_def->sqlcode, error_desc_def->errorText,
|
| error_desc_def->sqlstate);
|
| else
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_ERROR, error_desc_def->sqlcode, error_desc_def->errorText,
|
| error_desc_def->sqlstate);
|
| }
|
|
|
| }
|
|
|
| void CDiagRec::setDiagRec(const ERROR_DESC_LIST_def *sqlWarning)
|
| {
|
| IDL_unsigned_long curErrorNo;
|
| ERROR_DESC_def *error_desc_def;
|
|
|
| for (curErrorNo = 0, error_desc_def = sqlWarning->_buffer;
|
| curErrorNo < sqlWarning->_length ; curErrorNo++, error_desc_def++)
|
| {
|
|
|
| if( error_desc_def->errorCodeType == SQLERRWARN && error_desc_def->sqlcode == 0 && error_desc_def->errorText == NULL )
|
| continue;
|
|
|
| // Resource Governing
|
| if (error_desc_def->errorCodeType == ESTIMATEDCOSTRGERRWARN)
|
| {
|
| // Actual value: error_desc_def->Param4
|
| // Limit: error_desc_def->Param2
|
| setDiagRec(SERVER_ERROR, IDS_S1_000_08, ESTIMATEDCOSTRGERRWARN, NULL, NULL,
|
| SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 2,
|
| error_desc_def->Param4, error_desc_def->Param2);
|
|
|
| }
|
| else
|
| {
|
| if (error_desc_def->rowId > 0)
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_WARNING, error_desc_def->sqlcode, error_desc_def->errorText,
|
| error_desc_def->sqlstate, error_desc_def->rowId);
|
| else
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_WARNING, error_desc_def->sqlcode, error_desc_def->errorText,
|
| error_desc_def->sqlstate);
|
| }
|
| }
|
| }
|
|
|
| void CDiagRec::setDiagRec(BYTE *&WarningOrError, long returnCode)
|
| {
|
| long msg_total_len = 0;
|
|
|
| long numConditions = 0;
|
| char sqlState[6];
|
| long sqlCode;
|
| long errorTextLen = 0;
|
| char *errorText;
|
| long rowId = 0;
|
|
|
| sqlState[0] = '\0';
|
|
|
| unsigned char *curptr;
|
| int i;
|
|
|
| curptr = WarningOrError;
|
|
|
| numConditions = *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
|
|
| if (numConditions > 0)
|
| {
|
| DWORD IDS_SQL_temp = 0;
|
| if (returnCode == SQL_SUCCESS_WITH_INFO)
|
| IDS_SQL_temp = IDS_SQL_WARNING;
|
| else
|
| IDS_SQL_temp = IDS_SQL_ERROR;
|
|
|
| for (i = 0; i < numConditions; i++)
|
| {
|
| rowId= *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
|
|
| sqlCode= *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
|
|
| errorTextLen= *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
|
|
| if (errorTextLen > 0)
|
| {
|
| errorText = new char[errorTextLen];
|
| memcpy(errorText, curptr+msg_total_len, errorTextLen);
|
| msg_total_len +=errorTextLen;
|
| }
|
| else
|
| {
|
| errorText = new char[1];
|
| errorText[0] = '\0';
|
| }
|
|
|
| memcpy(sqlState, curptr+msg_total_len, sizeof(sqlState));
|
| sqlState[5] = '\0';
|
| msg_total_len +=sizeof(sqlState);
|
| if (rowId > 0)
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_temp, sqlCode, errorText, sqlState, rowId);
|
| else if (rowId == 0)
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_temp, sqlCode, errorText, sqlState, SQL_NO_ROW_NUMBER);
|
| else
|
| setDiagRec(SQLMX_ERROR, IDS_SQL_temp, sqlCode, errorText, sqlState);
|
| delete[] errorText;
|
| }
|
| }
|
| }
|
|
|
| void CDiagRec::setDiagRec(UINT nativeError, LPSTR funcName, char *srvrIdentity)
|
| {
|
| switch (nativeError)
|
| {
|
| case -29:
|
| setDiagRec(NETWORK_ERROR, IDS_KRYPTON_SRVR_GONE, nativeError, NULL, NULL, SQL_ROW_NUMBER_UNKNOWN,
|
| SQL_COLUMN_NUMBER_UNKNOWN, 2, funcName, srvrIdentity);
|
| break;
|
| case -27:
|
| setDiagRec(NETWORK_ERROR, IDS_KRYPTON_NO_SRVR, nativeError, NULL, NULL, SQL_ROW_NUMBER_UNKNOWN,
|
| SQL_COLUMN_NUMBER_UNKNOWN, 2, funcName, srvrIdentity);
|
| break;
|
| default:
|
| setDiagRec(NETWORK_ERROR, IDS_KRYPTON_ERROR, nativeError, NULL, NULL, SQL_ROW_NUMBER_UNKNOWN,
|
| SQL_COLUMN_NUMBER_UNKNOWN, 2, funcName, FORMAT_LAST_ERROR());
|
| }
|
| }
|
|
|
| SQLRETURN CDiagRec::GetDiagRec(SQLSMALLINT RecNumber,
|
| DWORD ErrorMsgLang,
|
| SQLWCHAR *SqlState,
|
| SQLINTEGER *NativeErrPtr,
|
| SQLWCHAR *MessageText,
|
| SQLSMALLINT BufferLength,
|
| SQLSMALLINT *TextLengthPtr)
|
| {
|
| CDiagStatusPtr diagStatusPtr;
|
| short strLen;
|
| short tmpStrLen;
|
| ODBCMXMSG_Def MsgStruct;
|
| SQLRETURN rc = SQL_SUCCESS;
|
| SQLINTEGER translateLength;
|
| SQLINTEGER translateLengthMax;
|
| UCHAR errorMsg[MAX_TRANSLATE_ERROR_MSG_LEN];
|
| char cTmpBuf[132];
|
|
|
| if (RecNumber <= (SQLSMALLINT)m_DiagStatusCollect.size())
|
| {
|
| GETDIAGRECPTR(diagStatusPtr, m_DiagStatusCollect, RecNumber-1);
|
|
|
| // Get the Formatted Message Text from mc file
|
| if (MAX_DIAG_PARAMS >= 4) // if MAX_DIAG_PARAMS is changed you may need to change here
|
| {
|
| gDrvrGlobal.gOdbcMsg.GetOdbcMessage(ErrorMsgLang, diagStatusPtr->m_DiagErrorCode, &MsgStruct,
|
| diagStatusPtr->m_DiagParams[0].c_str(), diagStatusPtr->m_DiagParams[1].c_str(),
|
| diagStatusPtr->m_DiagParams[2].c_str(), diagStatusPtr->m_DiagParams[3].c_str());
|
| }
|
| // Append the Message Text
|
| MsgStruct.lpsMsgText.append(diagStatusPtr->m_DiagMessageText);
|
| // Insert the Message Header
|
| MsgStruct.lpsMsgText.insert(0, gErrorMsgHeader[diagStatusPtr->m_DiagComponentCode]);
|
| // Append row id
|
| if(diagStatusPtr->m_DiagRowNumber>SQL_NO_ROW_NUMBER)
|
| {
|
| MsgStruct.lpsMsgText.append(" Row: ");
|
| MsgStruct.lpsMsgText.append(itoa(diagStatusPtr->m_DiagRowNumber,cTmpBuf,10));
|
| // Append column id
|
| if(diagStatusPtr->m_DiagColumnNumber>SQL_COLUMN_NUMBER_UNKNOWN)
|
| {
|
| MsgStruct.lpsMsgText.append(" Column: ");
|
| MsgStruct.lpsMsgText.append(itoa(diagStatusPtr->m_DiagColumnNumber,cTmpBuf,10));
|
| }
|
| }
|
| int transLen = 0;
|
| if (SqlState != NULL)
|
| {
|
| char tmpSqlState[6];
|
| char error[50];
|
| if (diagStatusPtr->m_DiagSqlState[0] != '\0')
|
| strncpy((char *)tmpSqlState, (const char *)diagStatusPtr->m_DiagSqlState, 5);
|
| else
|
| strncpy((char *)tmpSqlState, MsgStruct.lpsSQLState, 5);
|
| tmpSqlState[5] = 0;
|
| SqlState[0] = 0;
|
| //convert to UTF-16
|
| rc = UTF8ToWChar(tmpSqlState, 5, SqlState, 6, &transLen, error);
|
| if(pdwGlobalTraceVariable && *pdwGlobalTraceVariable && rc == SQL_ERROR)
|
| TraceOut(TR_ODBC_API, "CDiagRec::GetDiagRec: SqlState Error: tmpSqlState \"%s\"", tmpSqlState);
|
| }
|
| if (NativeErrPtr != NULL)
|
| *NativeErrPtr = diagStatusPtr->m_DiagNative;
|
| tmpStrLen = MsgStruct.lpsMsgText.size();
|
|
|
| //Double strLen to circumvent the bug in driver manager, that requires us to give
|
| //the NO. OF BYTES instead of no. of characters
|
| strLen = tmpStrLen * 2;
|
|
|
| translateLengthMax = (BufferLength == SQL_NTS) ? strLen : BufferLength;
|
|
|
| if (MessageText != NULL)
|
| {
|
| // translate from UTF8 to WChar
|
| if ( (rc = UTF8ToWChar((char *)MsgStruct.lpsMsgText.c_str(), tmpStrLen, MessageText,
|
| translateLengthMax/2, (int *)&translateLength, (char *)errorMsg)) != SQL_SUCCESS )
|
| rc = SQL_SUCCESS_WITH_INFO; //ERROR;
|
|
|
| ((wchar_t *)MessageText)[translateLength] = L'\0';
|
| strLen = tmpStrLen;
|
| }
|
| else
|
| {
|
| rc = SQL_SUCCESS_WITH_INFO;
|
| strLen = tmpStrLen;
|
| }
|
|
|
| if (TextLengthPtr != NULL)
|
| *TextLengthPtr = strLen;
|
| }
|
| else
|
| {
|
| if (SqlState != NULL)
|
| wcsncpy(SqlState, L"00000", 5);
|
| if (MessageText != NULL)
|
| MessageText[0] =L'\0';
|
| if (TextLengthPtr != NULL)
|
| *TextLengthPtr = 0;
|
| rc = SQL_NO_DATA;
|
| }
|
| return rc;
|
| }
|
|
|
| SQLRETURN CDiagRec::GetDiagField(SQLSMALLINT HandleType,
|
| SQLHANDLE Handle,
|
| SQLSMALLINT RecNumber,
|
| DWORD ErrorMsgLang,
|
| SQLSMALLINT DiagIdentifier,
|
| SQLPOINTER DiagInfoPtr,
|
| SQLSMALLINT BufferLength,
|
| SQLSMALLINT *StringLengthPtr)
|
| {
|
| short i;
|
| CDiagStatusPtr diagStatusPtr;
|
| ODBCMXMSG_Def MsgStruct;
|
| SQLINTEGER lStringLength;
|
| SQLRETURN rc = SQL_SUCCESS;
|
| RETURN_VALUE_STRUCT retValue;
|
|
|
| retValue.dataType = DRVR_PENDING;
|
| retValue.u.strPtr = NULL;
|
|
|
| switch (DiagIdentifier)
|
| {
|
| case SQL_DIAG_CURSOR_ROW_COUNT:
|
| #ifdef _WIN64
|
| retValue.u.s64Value = m_DiagCursorRowCount;
|
| retValue.dataType = SQL_C_SBIGINT;
|
| #else
|
| retValue.u.s32Value = m_DiagCursorRowCount;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| #endif
|
| break;
|
| case SQL_DIAG_DYNAMIC_FUNCTION:
|
| for (i = 0; ;i++)
|
| {
|
| if (diagFuncMap[i].diagFuncName == NULL)
|
| {
|
| retValue.u.strPtr = "SQL_DIAG_UNKNOWN_STATEMENT";
|
| break;
|
| }
|
| if (diagFuncMap[i].diagFuncCode == m_DiagDynamicFuncCode)
|
| {
|
| retValue.u.strPtr = diagFuncMap[i].diagFuncName;
|
| break;
|
| }
|
| }
|
| break;
|
| case SQL_DIAG_DYNAMIC_FUNCTION_CODE:
|
| retValue.u.s32Value = m_DiagDynamicFuncCode;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| break;
|
| case SQL_DIAG_NUMBER:
|
| retValue.u.s32Value = m_DiagStatusCollect.size();
|
| retValue.dataType = SQL_IS_INTEGER;
|
| break;
|
| case SQL_DIAG_RETURNCODE: // Implemented by DM
|
| break;
|
| case SQL_DIAG_ROW_COUNT:
|
| #ifdef _WIN64
|
| retValue.u.s64Value = m_DiagRowCount;
|
| retValue.dataType = SQL_C_SBIGINT;
|
| #else
|
| retValue.u.s32Value = m_DiagRowCount;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| #endif
|
| break;
|
| default:
|
| if (RecNumber <= 0)
|
| {
|
| rc = SQL_ERROR;
|
| break;
|
| }
|
| if (RecNumber > (SQLSMALLINT)m_DiagStatusCollect.size())
|
| {
|
| rc = SQL_NO_DATA;
|
| break;
|
| }
|
|
|
| GETDIAGRECPTR(diagStatusPtr, m_DiagStatusCollect, RecNumber-1);
|
| switch (DiagIdentifier)
|
| {
|
| case SQL_DIAG_CLASS_ORIGIN:
|
| if (strncmp((const char *)diagStatusPtr->m_DiagSqlState, "IM", 2) == 0)
|
| retValue.u.strPtr = "ODBC 3.0";
|
| else
|
| retValue.u.strPtr = "ISO 9075";
|
| break;
|
| case SQL_DIAG_CONNECTION_NAME:
|
| switch (HandleType)
|
| {
|
| case SQL_HANDLE_ENV:
|
| retValue.u.strPtr = EMPTY_STRING;
|
| break;
|
| case SQL_HANDLE_DBC:
|
| retValue.u.strPtr = ((CConnect *)Handle)->getSrvrIdentity();
|
| break;
|
| case SQL_HANDLE_STMT:
|
| break;
|
| default:
|
| retValue.u.strPtr = EMPTY_STRING;
|
| break;
|
| }
|
| break;
|
| case SQL_DIAG_MESSAGE_TEXT:
|
| // Get the Formatted Message Text from mc file
|
| if (MAX_DIAG_PARAMS >= 4) // if MAX_DIAG_PARAMS is changed you may need to change here
|
| {
|
| gDrvrGlobal.gOdbcMsg.GetOdbcMessage(ErrorMsgLang, diagStatusPtr->m_DiagErrorCode, &MsgStruct,
|
| diagStatusPtr->m_DiagParams[0].c_str(), diagStatusPtr->m_DiagParams[1].c_str(),
|
| diagStatusPtr->m_DiagParams[2].c_str(), diagStatusPtr->m_DiagParams[3].c_str());
|
| }
|
| // Append the Message Text
|
| MsgStruct.lpsMsgText.append(diagStatusPtr->m_DiagMessageText);
|
| // Insert the Message Header
|
| MsgStruct.lpsMsgText.insert(0, gErrorMsgHeader[diagStatusPtr->m_DiagComponentCode]);
|
| retValue.u.strPtr = (char *)MsgStruct.lpsMsgText.c_str();
|
| break;
|
| case SQL_DIAG_SERVER_NAME:
|
| switch (HandleType)
|
| {
|
| case SQL_HANDLE_ENV:
|
| retValue.u.strPtr = EMPTY_STRING;
|
| break;
|
| case SQL_HANDLE_DBC:
|
| retValue.u.strPtr = ((CConnect *)Handle)->getSrvrDSName();
|
| break;
|
| default:
|
| retValue.u.strPtr = EMPTY_STRING;
|
| break;
|
| }
|
| break;
|
| case SQL_DIAG_SQLSTATE:
|
| if (diagStatusPtr->m_DiagSqlState[0] != '\0')
|
| retValue.u.strPtr = (char *)diagStatusPtr->m_DiagSqlState;
|
| else
|
| {
|
| // Get the Formatted Message Text from mc file
|
| if (MAX_DIAG_PARAMS >= 4) // if MAX_DIAG_PARAMS is changed you may need to change here
|
| {
|
| gDrvrGlobal.gOdbcMsg.GetOdbcMessage(ErrorMsgLang, diagStatusPtr->m_DiagErrorCode, &MsgStruct,
|
| diagStatusPtr->m_DiagParams[0].c_str(), diagStatusPtr->m_DiagParams[1].c_str(),
|
| diagStatusPtr->m_DiagParams[2].c_str(), diagStatusPtr->m_DiagParams[3].c_str());
|
| }
|
| retValue.u.strPtr = (char *)MsgStruct.lpsSQLState;
|
| }
|
| break;
|
| case SQL_DIAG_SUBCLASS_ORIGIN:
|
| retValue.u.strPtr = EMPTY_STRING;
|
| break;
|
| case SQL_DIAG_COLUMN_NUMBER:
|
| retValue.u.s32Value = diagStatusPtr->m_DiagColumnNumber;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| break;
|
| case SQL_DIAG_ROW_NUMBER:
|
| #ifdef _WIN64
|
| retValue.u.s64Value = diagStatusPtr->m_DiagRowNumber;
|
| retValue.dataType = SQL_C_SBIGINT;
|
| #else
|
| retValue.u.s32Value = diagStatusPtr->m_DiagRowNumber;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| #endif
|
| break;
|
| case SQL_DIAG_NATIVE:
|
| retValue.u.s32Value = diagStatusPtr->m_DiagNative;
|
| retValue.dataType = SQL_IS_INTEGER;
|
| break;
|
| default:
|
| rc = SQL_ERROR;
|
| break;
|
| }
|
| }
|
| if (rc == SQL_SUCCESS)
|
| {
|
| rc = returnAttrValue(FALSE, NULL, &retValue, DiagInfoPtr, BufferLength, &lStringLength);
|
| if (StringLengthPtr != NULL)
|
| *StringLengthPtr = (short)lStringLength;
|
| }
|
| return rc;
|
| }
|
|
|
| void CDiagRec::setNTError(DWORD errorMsgLang, const char *FuncName)
|
| {
|
| LPVOID lpMsgBuf;
|
| DWORD error;
|
| char buffer[10];
|
|
|
| error = GetLastError();
|
| FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
| NULL,
|
| error,
|
| errorMsgLang,
|
| (LPTSTR) &lpMsgBuf,
|
| 0,
|
| NULL);
|
| setDiagRec(DRIVER_ERROR, IDS_NT_ERROR, error, (char *)lpMsgBuf, NULL,
|
| SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 2, FuncName, _itoa(error,buffer,10));
|
| LocalFree(lpMsgBuf);
|
| }
|
