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;
}
