RETCODE SQL_API SQLCancel ( HSTMT pStmt ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, "SQLCancel called" ) ); //if ( pStmt ) // // clear all previous diag info //{ _SQLFreeDiag ( & ( ( ( pODBCStmt ) pStmt )->Diag ) ); } return SQL_SUCCESS; }
RETCODE SQL_API SQLSetEnvAttr ( SQLHENV pEnv, SQLINTEGER pAttr, SQLPOINTER pDataPtr, SQLINTEGER pDataSize ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLSetEnvAttr called" ) ); __CHK_HANDLE ( pEnv, SQL_HANDLE_ENV, SQL_ERROR ); _SQLFreeDiag ( _DIAGENV ( pEnv ) ); switch ( pAttr ) { case SQL_ATTR_ODBC_VERSION : ( ( pODBCEnv ) pEnv ) -> AttrODBCVersion = ( ULong ) pDataPtr; break; case SQL_ATTR_CONNECTION_POOLING : ( ( pODBCEnv ) pEnv ) -> AttrConnPooling = ( ULong ) pDataPtr; break; case SQL_ATTR_CP_MATCH : ( ( pODBCEnv ) pEnv ) -> AttrCPMatch = ( ULong ) pDataPtr; break; case SQL_ATTR_OUTPUT_NTS : ( ( pODBCEnv ) pEnv ) -> AttrOutputNTS = ( ULong ) pDataPtr; break; default : return SQL_ERROR; // unknown attribute } return SQL_SUCCESS; }
RETCODE SQL_API SQLEndTran ( SQLSMALLINT pHandleType, SQLHANDLE pHandle, SQLSMALLINT pCompletionType ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLEndTran called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLEndTran not implemented" ) ); return SQL_ERROR; }
RETCODE SQL_API SQLPrepare ( SQLHSTMT pStmt, SQLCHAR* pStmtText, SQLINTEGER pTextLength ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLPrepare called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLPrepare not implemented, use SQLPrepareW" ) ); return SQL_ERROR; }
Word _SQLCopyDateTimeData ( pODBCDiag pDiag, void* pTgtDataPtr, Word pTgtDataType, CStrPtr pSrcData, Word pSrcDataType ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "_SQLCopyDateTimeData called, with the src : %s", pSrcData ) ); // note // source data is received as character string // source data type is also recd. but is not being checked right now // this can be used to detrmine if the conversion is possible at all bool isnull; // check if source data is NULL isnull = ( !pSrcData || _stricmp ( pSrcData, "NULL" ) == 0 ) ? TRUE : 0; // check if target is there if ( pTgtDataPtr ) { // check the data size switch ( pTgtDataType ) { case SQL_C_TYPE_DATE : // 91 case SQL_C_DATE : // ???? check src type if ( !isnull ) { memset ( pTgtDataPtr, 0, sizeof ( struct tagDATE_STRUCT) ); GetDateFromString ( pSrcData, ( struct tagDATE_STRUCT* ) pTgtDataPtr ); } break; case SQL_C_TYPE_TIME : // 92 case SQL_C_TIME : //not suppporting Time return 1; case SQL_C_TYPE_TIMESTAMP : // 93 case SQL_C_TIMESTAMP : // ???? check src type if ( !isnull ) { memset ( pTgtDataPtr, 0, sizeof ( struct tagTIMESTAMP_STRUCT) ); GetTimestampFromString ( pSrcData, ( struct tagTIMESTAMP_STRUCT* ) pTgtDataPtr ); } break; default : return 1; // data type not understood } return 0; // successful, at least data type recognized } else { return -1; } // should not typically happen }
RETCODE SQL_API SQLExecDirect ( SQLHSTMT pStmt, SQLCHAR* pStmtText, SQLINTEGER pTextLength ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLExecDirect called, strlen is %d, pTextLength is %d", strlen ( ( char* ) pStmtText ), pTextLength ) ); unique_ptr<wchar_t[]> pStmtTextW ( char2wchar ( ( char* ) pStmtText ) ); return SQLExecDirectW ( pStmt, ( SQLWCHAR* ) pStmtTextW.get(), pTextLength ); }
RETCODE SQL_API SQLSetCursorName ( SQLHSTMT pStmt, SQLCHAR* pDataPtr, SQLSMALLINT pDataSize ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLGetCursorName called" ) ); __CHK_HANDLE ( pStmt, SQL_HANDLE_STMT, SQL_ERROR ); _SQLFreeDiag ( _DIAGSTMT ( pStmt ) ); return SQL_SUCCESS; }
RETCODE SQL_API SQLSetPos ( SQLHSTMT pStmt, SQLUSMALLINT pRowNumber, SQLUSMALLINT pOperation, SQLUSMALLINT pLockType ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLSetPos called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLSetPos not implemented" ) ); return SQL_ERROR; }
// -------------------------------------------------------------------- // to set attributes specific to a connection // -------------------------------------------------------------------- RETCODE SQL_API SQLSetConnectAttrW ( SQLHDBC hdbc, SQLINTEGER fAttribute, SQLPOINTER rgbValue, SQLINTEGER cbValue ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLSetConnectAttrW, Attr: %d, DataPtr: %d, DataSize: %d", fAttribute, rgbValue, cbValue ) ); RETCODE code = SQLSetConnectAttr ( hdbc, fAttribute, rgbValue, cbValue ); return code; }
RETCODE SQL_API SQLGetStmtAttrW ( SQLHSTMT pStmt, SQLINTEGER pAttr, SQLPOINTER pDataPtr, SQLINTEGER pDataSize, SQLINTEGER* pDataSizePtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLGetStmtAttrW, Attr: %d, DataPtr: %d, DataSize: %d", pAttr, pDataPtr, pDataSize ) ); return SQLGetStmtAttr ( pStmt, pAttr, pDataPtr, pDataSize, pDataSizePtr ); }
RETCODE TryFetchMetadata ( pODBCConn pgConn ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "start loading metadata..." ) ); try { pgConn->meta = std::move ( restGetMeta ( pgConn->Server, pgConn->ServerPort, pgConn->UserName, pgConn->Password, pgConn->Project ) ); } catch ( const exception& e ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_ERROR, "The REST request failed to get metadata" ) ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_ERROR, e.what() ) ); _SQLPutDiagRow ( SQL_HANDLE_DBC, pgConn, "SQLDriverConnect", "HY000", 1045, "Access denied. (using password: NO)" ); return SQL_ERROR; } __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "End loading metadata" ) ); return SQL_SUCCESS; }
pODBCDiagRow _SQLPutDiagRow ( pODBCDiag pDiag, StrPtr pFunc, StrPtr pState, Long pNativeErrorCode, StrPtr pMsgArgs, va_list pArgs ) { Char s[4096]; // arbitary and maximum length of message pODBCDiagRow l; pODBCDiagRow r; // first set the value of source function, assuming less than 64 if ( pFunc ) { strcpy ( pDiag->Func, pFunc ); } // create message template strcpy ( s, "[Kylin][ODBC 1.0(w) Driver]" ); // check if there is some message if ( pMsgArgs ) { vsprintf ( s + strlen ( s ), pMsgArgs, pArgs ); } else { strcat ( s, "(unknown)" ); } // allocate a new row r = new ODBCDiagRow; // reset memset ( r, 0, sizeof ( ODBCDiagRow ) ); // set the values for state and native error code if ( pState ) { strncpy ( r->State, pState, SQL_SQLSTATE_SIZE ); } r->NativeErrorCode = pNativeErrorCode; // allocate space for message r->Msg = new Char[strlen ( s ) + 1]; strcpy ( r->Msg, s ); // set the default row and col values r->Row = SQL_ROW_NUMBER_UNKNOWN; r->Col = SQL_COLUMN_NUMBER_UNKNOWN; __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "DiagMsg: %s", s ) ); // ATTACH TO LIST // check for any existing rows if ( pDiag->DiagRows ) { // iterate to last row for ( l = pDiag->DiagRows; l->Next != NULL; l = l->Next ); // attach l->Next = r; // next of last row r->Prev = l; // last row becomes the prev row of this row } else { // make it the first row pDiag->DiagRows = r; } return r; }
RETCODE SQL_API SQLColAttribute ( SQLHSTMT pStmt, SQLUSMALLINT pColNum, SQLUSMALLINT pFldID, SQLPOINTER pDataPtr, SQLSMALLINT pDataSize, SQLSMALLINT* pDataSizePtr, SQLPOINTER pNumValuePtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLColAttributeW called, ColNum: %d, FldID: %d", pColNum, pFldID ) ); return _SQLColAttribute_basic ( pStmt, pColNum, pFldID, pDataPtr, pDataSize, pDataSizePtr, pNumValuePtr, true ); }
RETCODE SQL_API SQLGetData ( SQLHSTMT pStmt, SQLUSMALLINT pColNum, SQLSMALLINT pgtType, SQLPOINTER pDataPtr, SQLINTEGER pDataSize, SQLINTEGER* pDataSizePtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLGetData called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLGetData not implemented" ) ); return SQL_ERROR; }
RETCODE SQL_API SQLBrowseConnect ( SQLHDBC pConn, SQLCHAR* InConnectionString, SQLSMALLINT StringLength1, SQLCHAR* OutConnectionString, SQLSMALLINT BufferLength, SQLSMALLINT* StringLength2Ptr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLBrowseConnect called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLBrowseConnect - not implemented, use SQLDriverConnect" ) ); return SQL_ERROR; }
RETCODE SQL_API SQLNativeSql ( SQLHDBC pConn, SQLCHAR* pInStmtText, SQLINTEGER pInStmtTextLen, SQLCHAR* pOutStmtText, SQLINTEGER pOutStmtTextLen, SQLINTEGER* pOutStmtTextLenPtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLNativeSql called" ) ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLNativeSql not implemented" ) ); return SQL_ERROR; }
// ----------------------------------------------------------------------- // to get param descriptions for a specified bound param // ----------------------------------------------------------------------- RETCODE SQL_API SQLDescribeParam(SQLHSTMT pStmt, SQLUSMALLINT pParamNum, SQLSMALLINT* pDataTypePtr, SQLUINTEGER* pParamSizePtr, SQLSMALLINT* pDecimalDigitsPtr, SQLSMALLINT* pNullablePtr) { __ODBCLOG(_ODBCLogMsg(LogLevel_DEBUG, "SQLDescribeParam called")); __ODBCPOPMSG(_ODBCPopMsg("SQLDescribeParam not implemented")); return SQL_ERROR; }
RETCODE TryAuthenticate ( pODBCConn pgConn ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "Start authenticating.." ) ); try { bool authenticated = restAuthenticate ( pgConn->Server, pgConn->ServerPort, pgConn->UserName, pgConn->Password ); if ( !authenticated ) { throw exception ( "Username/Password incorrect." ); } } catch ( const exception& e ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_ERROR, "The REST request failed to authenticate." ) ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_ERROR, e.what() ) ); _SQLPutDiagRow ( SQL_HANDLE_DBC, pgConn, "SQLDriverConnect", "HY000", 1045, "Access denied. (using password: NO)" ); return SQL_ERROR; } __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "End authenticating" ) ); return SQL_SUCCESS; }
RETCODE SQL_API SQLGetDiagRecW ( SQLSMALLINT pHandleType, SQLHANDLE pHandle, SQLSMALLINT pRecNum, SQLWCHAR* pSqlstate, SQLINTEGER* pNativeErrorPtr, SQLWCHAR* pMsgTxtPtr, SQLSMALLINT pMsgTxtSize, SQLSMALLINT* pMsgTxtSizePtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLGetDiagRecW called, HandleType: %d, RecNum: %d, BufLen: %d", pHandleType, pRecNum, pMsgTxtSize ) ); pODBCDiag diag; pODBCDiagRow diagrow; __CHK_HANDLE ( pHandle, pHandleType, SQL_ERROR ); diag = _SQLGetDiagHandle ( pHandleType, pHandle ); if ( !diag ) { return SQL_ERROR; } // now get the desired diag row if ( ( diagrow = _SQLGetDiagRowX ( diag, pRecNum ) ) == NULL ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "sql no data" ) ); return SQL_NO_DATA; } // sql-state if ( pSqlstate ) { char2wchar ( diagrow->State, pSqlstate, -1 ); } // native error code if ( pNativeErrorPtr ) { ( *pNativeErrorPtr ) = diagrow->NativeErrorCode; } // msg __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "The message is %s", diagrow->Msg ) ); _SQLCopyWCharData ( diag, pMsgTxtPtr, pMsgTxtSize, pMsgTxtSizePtr, 16, diagrow->Msg, -1 ); // debug //__ODBCLOG(_ODBCLogMsg(LogLevel_DEBUG,"SQLGetDiagRec msg: %s", pMsgTxtPtr ? ( StrPtr )pMsgTxtPtr : "(unknown)" )); RETCODE ret = ( pMsgTxtSizePtr && ( *pMsgTxtSizePtr ) > pMsgTxtSize ) ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS; __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "The SQLGetDiagRecW return code is %d", ret ) ); return ret; }
// ----------------------------------------------------------------------- // to get the number of parameters in a statement // ----------------------------------------------------------------------- RETCODE SQL_API SQLNumParams(SQLHSTMT pStmt, SQLSMALLINT* pParamCountPtr) { // since the concept of parameters has not been implemented // this function returns zero in the number of params to // make sure that the calle does not proceed forward on this issue __ODBCLOG(_ODBCLogMsg(LogLevel_DEBUG, "SQLNumParams called")); if (pParamCountPtr) { *pParamCountPtr = 0; } return SQL_SUCCESS; }
RETCODE SQL_API _SQLExecStmtFromReq ( pODBCStmt pStmt, bool pPrepared ) { ////// this part should not be required if already prepared // release existing stmt contents //SQLFreeStmt ( pStmt, SQL_CLOSE ); ////// __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, "================================================================" ) ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, "start exec the query: " ) ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, pStmt->Stmt ) ); std::unique_ptr<SQLResponse> p; try { p = restQuery ( pStmt->Stmt, pStmt->Conn->Server, pStmt->Conn->ServerPort, pStmt->Conn->UserName, pStmt->Conn->Password, pStmt->Conn->Project ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "The REST request succeed" ) ); } catch ( const exception& e ) { std::stringstream ss; ss << "The REST query request failed, the error message is: " << e.what(); std::string s = ss.str(); __ODBCLOG ( _ODBCLogMsg ( LogLevel_ERROR, s.c_str() ) ); _SQLPutDiagRow ( SQL_HANDLE_STMT, pStmt, "_SQLExecStmtFromReq", "01000", -1, ( char* ) s.c_str() ); return SQL_ERROR; } // feed stmt structure with response, stmt will take charge of deleting it if ( p == NULL || p->isException == true || PutRespToStmt ( ( pODBCStmt ) pStmt, std::move ( p ) ) != GOOD ) { return SQL_ERROR; } __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, "Successfully done executing the query" ) ); return SQL_SUCCESS; }
RETCODE SQL_API SQLNumResultCols ( SQLHSTMT pStmt, SQLSMALLINT* pColCountPtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLNumResultCols called" ) ); SQLResponse* rowdesc; __CHK_HANDLE ( pStmt, SQL_HANDLE_STMT, SQL_ERROR ); // free diags _SQLFreeDiag ( _DIAGSTMT ( pStmt ) ); // caller safe * ( ( SQLSMALLINT* ) pColCountPtr ) = 0; // get the row desciptor rowdesc = ( ( pODBCStmt ) pStmt )->IRD.RowDesc.get(); if ( rowdesc == NULL ) { _SQLPutDiagRow ( SQL_HANDLE_STMT, pStmt, "SQLNumResultCols", "01000", -1, "no resultset or IRD" ); return SQL_ERROR; } // count the number of columns * ( ( SQLSMALLINT* ) pColCountPtr ) = ( SQLSMALLINT ) ( rowdesc->columnMetas.size() ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLNumResultCols called returned: %d", * ( ( SQLSMALLINT* ) pColCountPtr ) ) ); return SQL_SUCCESS; }
// ----------------------------------------------------------------------- // to bind a buffer to a parameter marker in an SQL statement // ----------------------------------------------------------------------- RETCODE SQL_API SQLBindParameter(SQLHSTMT pStmt, SQLUSMALLINT pParamNum, SQLSMALLINT pIOType, SQLSMALLINT pValueType, SQLSMALLINT pParamType, SQLUINTEGER pColSize, SQLSMALLINT pDecimalDigits, SQLPOINTER pParamValuePtr, SQLINTEGER pParamValueSize, SQLINTEGER* pParamValueSizePtr) { __ODBCLOG(_ODBCLogMsg(LogLevel_DEBUG, "SQLBindParameter called")); __ODBCPOPMSG(_ODBCPopMsg("SQLBindParameter not implemented")); return SQL_ERROR; }
RETCODE SQL_API SQLConnect ( SQLHDBC pConn, SQLCHAR* pServerName, SQLSMALLINT pServerNameLen, SQLCHAR* pUserName, SQLSMALLINT pUserNameLen, SQLCHAR* pPassword, SQLSMALLINT pPasswordLen ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLConnect called" ) ); __CHK_HANDLE ( pConn, SQL_HANDLE_DBC, SQL_ERROR ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLConnect - not implemented, use SQLDriverConnect" ) ); return SQL_ERROR; _SQLFreeDiag ( _DIAGCONN ( pConn ) ); return ( SQL_SUCCESS ); }
SQLRETURN SQL_API SQLConnectW ( SQLHDBC hdbc, SQLWCHAR* szDSN, SQLSMALLINT cchDSN, SQLWCHAR* szUID, SQLSMALLINT cchUID, SQLWCHAR* szAuthStr, SQLSMALLINT cchAuthStr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLConnectW called" ) ); __CHK_HANDLE ( hdbc, SQL_HANDLE_DBC, SQL_ERROR ); __ODBCPOPMSG ( _ODBCPopMsg ( "SQLConnectW - not implemented, use SQLDriverConnectW" ) ); return SQL_ERROR; _SQLFreeDiag ( _DIAGCONN ( hdbc ) ); return ( SQL_SUCCESS ); }
SQLRETURN SQL_API SQLDescribeCol ( SQLHSTMT pStmt, SQLUSMALLINT pColNum, SQLCHAR* pColNamePtr, SQLSMALLINT pColNameSize, SQLSMALLINT* pColNameSizePtr, SQLSMALLINT* pDataTypePtr, SQLULEN* pColSizePtr, SQLSMALLINT* pDecimalDigitsPtr, SQLSMALLINT* pNullablePtr ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLDescribeCol. Col: %d, ColNamePtr: %d, ColNameSize: %d, ColNameSizePtr: %d, DataTypePtr: %d, ColSizePtr: %d, DecDigitsPtr: %d, NullPtr: %d", pColNum, pColNamePtr, pColNameSize, pColNameSizePtr, pDataTypePtr, pColSizePtr, pDecimalDigitsPtr, pNullablePtr ) ); return _SQLDescribeCol_basic ( pStmt, pColNum, pColNamePtr, pColNameSize, pColNameSizePtr, pDataTypePtr, pColSizePtr, pDecimalDigitsPtr, pNullablePtr , true ); }
RETCODE SQL_API SQLFetch ( HSTMT pStmt ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLFetch called" ) ); __CHK_HANDLE ( pStmt, SQL_HANDLE_STMT, SQL_ERROR ); // free diags _SQLFreeDiag ( _DIAGSTMT ( pStmt ) ); // all fetch occur thru the local function _SQLFetch /* RETCODE SQL_API _SQLFetch ( pODBCStmt pStmt, Word pFetchOrientation, Long pFetchOffset, ULong* pRowCountPtr, UWord* pRowStatusArray ) */ RETCODE ret = _SQLFetch ( ( pODBCStmt ) pStmt, SQL_FETCH_NEXT, ( ( pODBCStmt ) pStmt )->ARD.RowArraySize > 0 ? ( ( pODBCStmt ) pStmt )->ARD.RowArraySize : 1, ( ( pODBCStmt ) pStmt )->IRD.RowsProcessedPtr, ( ( pODBCStmt ) pStmt )->IRD.ArrayStatusPtr ); if ( ret == SQL_NO_DATA ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_INFO, "Last row of current query has been fetched" ) ); } __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLFetch exiting" ) ); return ret; }
// ----------------------------------------------------------------------- // to connect to the driver // ----------------------------------------------------------------------- RETCODE SQL_API SQLDriverConnectW ( SQLHDBC hdbc, SQLHWND hwnd, SQLWCHAR* szConnStrIn, SQLSMALLINT cchConnStrIn, SQLWCHAR* szConnStrOut, SQLSMALLINT cchConnStrOutMax, SQLSMALLINT* pcchConnStrOut, SQLUSMALLINT fDriverCompletion ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLDriverConnectW called, cchConnStrIn %d, cchConnStrOutMax %d, wcslen %d", cchConnStrIn, cchConnStrOutMax, wcslen ( szConnStrIn ) ) ); int inStrLength = wcslen ( szConnStrIn ) + 1; __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "The inStr Length is : %d", inStrLength ) ); unique_ptr<char[]> pInStr ( new char[inStrLength] ); unique_ptr<char[]> pOutStr ( new char[cchConnStrOutMax + 1] ); wchar2char ( szConnStrIn, pInStr.get(), inStrLength ); //__ODBCLOG(_ODBCLogMsg(LogLevel_DEBUG,"The inStr is : %s",pInStr.get())); SQLSMALLINT outStrLength = 0 ; RETCODE code = SQLDriverConnect ( hdbc, hwnd, ( SQLCHAR* ) pInStr.get(), cchConnStrIn, ( SQLCHAR* ) pOutStr.get(), cchConnStrOutMax, &outStrLength, fDriverCompletion ); if ( code == SQL_ERROR ) { return code; } __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "pcchConnStrOut null? %d, cchConnStrOutMax > 0 ? %d, szConnStrOut null? %d", pcchConnStrOut == NULL, cchConnStrOutMax > 0 , szConnStrOut == NULL ) ); if ( cchConnStrOutMax > 0 && pcchConnStrOut && szConnStrOut ) { char2wchar ( pOutStr.get(), szConnStrOut, ( int ) cchConnStrOutMax ); *pcchConnStrOut = wcslen ( szConnStrOut ); __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "(W)The Length of Out Conn Str is %d", *pcchConnStrOut ) ); } __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "the ret code is %d", code ) ); return code; }
void _ODBCPopMsg ( const char* pMsgArgs, ... ) { Char s[4096]; // arbitary and maximum length of message va_list args; // check if there is some message if ( pMsgArgs ) { // convert to full msg including parsed params va_start ( args, pMsgArgs ); vsprintf ( s, pMsgArgs, args ); va_end ( args ); } else { s[0] = 0; } _ODBCLogMsg ( LogLevel_FATAL, s ); #ifdef SHIPPING // no thing _ODBCLogMsg ( LogLevel_FATAL, "In Shipping mode, Skip popping up window..." ); #else // show as window MessageBox ( GetDesktopWindow(), s, "Kylin ODBC Says :", MB_OK ); #endif }
RETCODE SQL_API SQLExecute ( HSTMT pStmt ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLExecute called on: %d", pStmt ) ); Word x; __CHK_HANDLE ( pStmt, SQL_HANDLE_STMT, SQL_ERROR ); _SQLFreeDiag ( _DIAGSTMT ( pStmt ) ); // check if prepared if ( ( ( pODBCStmt ) pStmt )->Prepared != 1 ) { _SQLPutDiagRow ( SQL_HANDLE_STMT, pStmt, "SQLExecute", "01000", -1, "No prepared stmt" ); return SQL_ERROR; } // excute the request x = _SQLExecStmtFromReq ( ( pODBCStmt ) pStmt, 1 ); return x; }