SQLRETURN SQL_API SQLSetStmtAttr( SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength) { HDRVSTMT hStmt = (HDRVSTMT)StatementHandle; LOG_DEBUG_F_FUNC( TEXT("%s: StatementHandle = 0x%08lX, Attribute = %d, ") TEXT("ValuePtr = 0x%08lX, StringLength = %d"), LOG_FUNCTION_NAME, (long)StatementHandle, Attribute, (long)ValuePtr, StringLength); /* SANITY CHECKS */ ODBCAPIHelper helper(hStmt, SQL_HANDLE_STMT); if(!helper.IsValid()) return SQL_INVALID_HANDLE; helper.Lock(); API_HOOK_ENTRY(SQLSetStmtAttr, StatementHandle, Attribute, ValuePtr, StringLength); switch(Attribute) { // HY017 case SQL_ATTR_APP_PARAM_DESC: case SQL_ATTR_APP_ROW_DESC: case SQL_ATTR_IMP_PARAM_DESC: case SQL_ATTR_IMP_ROW_DESC: LOG_DEBUG_F_FUNC( TEXT("Setting APD, ARD, IPD, IRD: ValuePtr=$%08lX ") TEXT("(Cannot set descriptor.)"), ValuePtr); API_HOOK_RETURN(SQL_ERROR); case SQL_ATTR_ASYNC_ENABLE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ASYNC_ENABLE: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->asyncEnable = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_CONCURRENCY: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_CONCURRENCY: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->concurrency = (SQLUINTEGER)((std::size_t)ValuePtr); if(hStmt->hStmtExtras->concurrency == SQL_CONCUR_READ_ONLY) hStmt->hStmtExtras->cursorSensitivity = SQL_INSENSITIVE; else hStmt->hStmtExtras->cursorSensitivity = SQL_UNSPECIFIED; break; case SQL_ATTR_CURSOR_SCROLLABLE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_CURSOR_SCROLLABLE: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->cursorScroll = (SQLUINTEGER)((std::size_t)ValuePtr); if(hStmt->hStmtExtras->cursorScroll == SQL_NONSCROLLABLE) hStmt->hStmtExtras->cursorType = SQL_CURSOR_FORWARD_ONLY; else hStmt->hStmtExtras->cursorType = SQL_CURSOR_STATIC; break; case SQL_ATTR_CURSOR_SENSITIVITY: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_CURSOR_SENSITIVITY: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->cursorSensitivity = (SQLUINTEGER)((std::size_t)ValuePtr); if(hStmt->hStmtExtras->cursorSensitivity == SQL_INSENSITIVE) { hStmt->hStmtExtras->concurrency = SQL_CONCUR_READ_ONLY; hStmt->hStmtExtras->cursorType = SQL_CURSOR_STATIC; } else if(hStmt->hStmtExtras->cursorSensitivity == SQL_SENSITIVE) { hStmt->hStmtExtras->concurrency = SQL_CONCUR_ROWVER; hStmt->hStmtExtras->cursorType = SQL_CURSOR_STATIC; } else // if ( cursorSensitivity == SQL_UNSPECIFIED ) { hStmt->hStmtExtras->concurrency = SQL_CONCUR_READ_ONLY; hStmt->hStmtExtras->cursorType = SQL_CURSOR_FORWARD_ONLY; } break; case SQL_ATTR_CURSOR_TYPE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_CURSOR_TYPE: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->cursorType = (SQLUINTEGER)((std::size_t)ValuePtr); if(hStmt->hStmtExtras->cursorType == SQL_CURSOR_DYNAMIC) { hStmt->hStmtExtras->cursorScroll = SQL_SCROLLABLE; if(hStmt->hStmtExtras->concurrency != SQL_CONCUR_READ_ONLY) hStmt->hStmtExtras->cursorSensitivity = SQL_SENSITIVE; } else if(hStmt->hStmtExtras->cursorType == SQL_CURSOR_FORWARD_ONLY) { hStmt->hStmtExtras->cursorScroll = SQL_NONSCROLLABLE; } else if(hStmt->hStmtExtras->cursorType == SQL_CURSOR_KEYSET_DRIVEN) { hStmt->hStmtExtras->cursorScroll = SQL_SCROLLABLE; if(hStmt->hStmtExtras->concurrency != SQL_CONCUR_READ_ONLY) hStmt->hStmtExtras->cursorSensitivity = SQL_UNSPECIFIED; } else if(hStmt->hStmtExtras->cursorType == SQL_CURSOR_STATIC) { hStmt->hStmtExtras->cursorScroll = SQL_SCROLLABLE; if(hStmt->hStmtExtras->concurrency != SQL_CONCUR_READ_ONLY) hStmt->hStmtExtras->cursorSensitivity = SQL_UNSPECIFIED; else hStmt->hStmtExtras->cursorSensitivity = SQL_INSENSITIVE; } break; case SQL_ATTR_ENABLE_AUTO_IPD: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ENABLE_AUTO_IPD: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->autoIPD = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_FETCH_BOOKMARK_PTR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_FETCH_BOOKMARK_PTR: ValuePtr=$%08lX ") TEXT("(NOT IMPLEMENTED)"), (SQLLEN*)((std::size_t)ValuePtr)); break; case SQL_ATTR_KEYSET_SIZE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_KEYSET_SIZE: ValuePtr=%u"), (SQLULEN)((std::size_t)ValuePtr)); hStmt->hStmtExtras->keysetSize = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_MAX_LENGTH: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_MAX_LENGTH: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLULEN)((std::size_t)ValuePtr)); break; case SQL_ATTR_MAX_ROWS: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_MAX_ROWS: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLULEN)((std::size_t)ValuePtr)); break; case SQL_ATTR_METADATA_ID: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_METADATA_ID: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->metaDataID = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_NOSCAN: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_NOSCAN: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->noScan = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_PARAM_BIND_OFFSET_PTR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAM_BIND_OFFSET_PTR: ValuePtr=$%08lX ") TEXT("(NOT IMPLEMENTED)"), (SQLULEN*)((std::size_t)ValuePtr)); break; case SQL_ATTR_PARAM_BIND_TYPE: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAM_BIND_TYPE: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLUINTEGER)((std::size_t)ValuePtr)); break; case SQL_ATTR_PARAM_OPERATION_PTR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAM_OPERATION_PTR: ValuePtr=$%08lX ") TEXT("(NOT IMPLEMENTED)"), (SQLUSMALLINT*)((std::size_t)ValuePtr)); break; case SQL_ATTR_PARAM_STATUS_PTR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAM_STATUS_PTR: ValuePtr=$%08lX ") TEXT("(NOT IMPLEMENTED)"), (SQLUSMALLINT*)((std::size_t)ValuePtr)); break; case SQL_ATTR_PARAMS_PROCESSED_PTR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAMS_PROCESSED_PTR: ValuePtr=$%08lX ") TEXT("(NOT IMPLEMENTED)"), (SQLULEN*)((std::size_t)ValuePtr)); break; case SQL_ATTR_PARAMSET_SIZE: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_PARAMSET_SIZE: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLULEN)((std::size_t)ValuePtr)); break; case SQL_ATTR_QUERY_TIMEOUT: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_QUERY_TIMEOUT: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->queryTimeout = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ATTR_RETRIEVE_DATA: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_RETRIEVE_DATA: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); hStmt->hStmtExtras->retrieveData = (SQLUINTEGER)((std::size_t)ValuePtr); break; case SQL_ROWSET_SIZE: case SQL_ATTR_ROW_ARRAY_SIZE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROW_ARRAY_SIZE: ValuePtr=%u"), (SQLULEN)((std::size_t)ValuePtr)); _SQLSetARDField(&hStmt->hStmtExtras->ard, SQL_DESC_ARRAY_SIZE, ValuePtr, StringLength); break; case SQL_ATTR_ROW_BIND_OFFSET_PTR: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROW_BIND_OFFSET_PTR: ValuePtr=$%08lX"), (SQLULEN*)((std::size_t)ValuePtr)); _SQLSetARDField(&hStmt->hStmtExtras->ard, SQL_DESC_BIND_OFFSET_PTR, ValuePtr, StringLength); break; case SQL_ATTR_ROW_BIND_TYPE: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROW_BIND_TYPE: ValuePtr=%u"), (SQLUINTEGER)((std::size_t)ValuePtr)); _SQLSetARDField(&hStmt->hStmtExtras->ard, SQL_DESC_BIND_TYPE, ValuePtr, StringLength); break; case SQL_ATTR_ROW_NUMBER: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_ROW_NUMBER: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLUINTEGER)((std::size_t)ValuePtr)); break; case SQL_ATTR_ROW_OPERATION_PTR: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROW_OPERATION_PTR: ValuePtr=$%08lX"), (SQLUSMALLINT*)((std::size_t)ValuePtr)); _SQLSetARDField(&hStmt->hStmtExtras->ard, SQL_DESC_ARRAY_STATUS_PTR, ValuePtr, StringLength); break; case SQL_ATTR_ROW_STATUS_PTR: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROW_STATUS_PTR: ValuePtr=$%08lX"), (SQLUSMALLINT*)((std::size_t)ValuePtr)); _SQLSetIRDField(&hStmt->hStmtExtras->ird, SQL_DESC_ARRAY_STATUS_PTR, ValuePtr, StringLength); break; case SQL_ATTR_ROWS_FETCHED_PTR: LOG_DEBUG_F_FUNC( TEXT("Setting SQL_ATTR_ROWS_FETCHED_PTR: ValuePtr=$%08lX"), (SQLULEN*)((std::size_t)ValuePtr)); _SQLSetIRDField(&hStmt->hStmtExtras->ird, SQL_DESC_ROWS_PROCESSED_PTR, ValuePtr, StringLength); break; case SQL_ATTR_SIMULATE_CURSOR: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_SIMULATE_CURSOR: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLUINTEGER)((std::size_t)ValuePtr)); break; case SQL_ATTR_USE_BOOKMARKS: LOG_WARN_F_FUNC( TEXT("Setting SQL_ATTR_USE_BOOKMARKS: ValuePtr=%u (NOT IMPLEMENTED)"), (SQLUINTEGER)((std::size_t)ValuePtr)); break; default: LOG_WARN_F_FUNC(TEXT("Setting Invalid Statement Attribute=%d"), Attribute); API_HOOK_RETURN(SQL_ERROR); } LOG_WARN_F_FUNC(TEXT("%s: This function partially supported."), LOG_FUNCTION_NAME); LOG_DEBUG_F_FUNC(TEXT("%s: SQL_SUCCESS"), LOG_FUNCTION_NAME); API_HOOK_RETURN(SQL_SUCCESS); }
RETCODE SQL_API SQLSetStmtAttr ( SQLHSTMT pStmt, SQLINTEGER pAttr, SQLPOINTER pDataPtr, SQLINTEGER pDataSize ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLSetStmtAttr, Attr: %d, DataPtr: %d, DataSize: %d", pAttr, pDataPtr, pDataSize ) ); __CHK_HANDLE ( pStmt, SQL_HANDLE_STMT, SQL_ERROR ); _SQLFreeDiag ( _DIAGSTMT ( pStmt ) ); switch ( pAttr ) { case SQL_ATTR_APP_PARAM_DESC : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_APP_PARAM_DESC - Cannot set descriptor" ) ); return SQL_ERROR; case SQL_ATTR_APP_ROW_DESC : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_APP_ROW_DESC - Cannot set descriptor" ) ); return SQL_ERROR; case SQL_ATTR_ASYNC_ENABLE : ( ( pODBCStmt ) pStmt ) -> AsyncEnable = ( ULong ) pDataPtr; break; case SQL_ATTR_CONCURRENCY : ( ( pODBCStmt ) pStmt ) -> Concurrency = ( ULong ) pDataPtr; break; case SQL_ATTR_CURSOR_SCROLLABLE : ( ( pODBCStmt ) pStmt ) -> CursorScroll = ( ULong ) pDataPtr; break; case SQL_ATTR_CURSOR_SENSITIVITY : ( ( pODBCStmt ) pStmt ) -> CursorSensitivity = ( ULong ) pDataPtr; break; case SQL_ATTR_CURSOR_TYPE : ( ( pODBCStmt ) pStmt ) -> CursorType = ( ULong ) pDataPtr; break; case SQL_ATTR_ENABLE_AUTO_IPD : ( ( pODBCStmt ) pStmt ) -> AutoIPD = ( ULong ) pDataPtr; break; case SQL_ATTR_FETCH_BOOKMARK_PTR : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_FETCH_BOOKMARK_PTR - option not implemented" ) ); return SQL_ERROR; case SQL_ATTR_IMP_PARAM_DESC : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_IMP_PARAM_DESC - Cannot set descriptor" ) ); return SQL_ERROR; case SQL_ATTR_IMP_ROW_DESC : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_IMP_ROW_DESC - Cannot set descriptor" ) ); return SQL_ERROR; case SQL_ATTR_KEYSET_SIZE : ( ( pODBCStmt ) pStmt ) -> KeysetSize = ( ULong ) pDataPtr; break; case SQL_ATTR_MAX_LENGTH : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_MAX_LENGTH - option not implemented" ) ); return SQL_ERROR; case SQL_ATTR_MAX_ROWS : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_MAX_ROWS - option not implemented" ) ); return SQL_ERROR; case SQL_ATTR_METADATA_ID : ( ( pODBCStmt ) pStmt ) -> MetaDataID = ( ULong ) pDataPtr; break; case SQL_ATTR_NOSCAN : ( ( pODBCStmt ) pStmt ) -> NoScan = ( ULong ) pDataPtr; break; case SQL_ATTR_PARAM_BIND_TYPE : _SQLSetAPDField ( & ( ( ( pODBCStmt ) pStmt ) -> APD ), SQL_DESC_BIND_TYPE, pDataPtr, pDataSize ); break; case SQL_ATTR_PARAM_BIND_OFFSET_PTR : _SQLSetAPDField ( & ( ( ( pODBCStmt ) pStmt ) -> APD ), SQL_DESC_BIND_OFFSET_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_PARAM_OPERATION_PTR : _SQLSetAPDField ( & ( ( ( pODBCStmt ) pStmt ) -> APD ), SQL_DESC_ARRAY_STATUS_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_PARAM_STATUS_PTR : _SQLSetIPDField ( & ( ( ( pODBCStmt ) pStmt ) -> IPD ), SQL_DESC_ARRAY_STATUS_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_PARAMS_PROCESSED_PTR : // ???? note there is an error in MSDN on SQLSetDescField which says ARD/APD instead of IRD/IPD for this option _SQLSetIPDField ( & ( ( ( pODBCStmt ) pStmt ) -> IPD ), SQL_DESC_ROWS_PROCESSED_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_PARAMSET_SIZE : _SQLSetAPDField ( & ( ( ( pODBCStmt ) pStmt ) -> APD ), SQL_DESC_ARRAY_SIZE, pDataPtr, pDataSize ); break; case SQL_ATTR_QUERY_TIMEOUT : if ( pDataPtr != NULL ) { ( ( pODBCStmt ) pStmt ) -> QryTimeout = * ( ( ULong* ) pDataPtr ); } break; case SQL_ATTR_RETRIEVE_DATA : ( ( pODBCStmt ) pStmt ) -> RetrieveData = ( ULong ) pDataPtr; break; case SQL_ROWSET_SIZE : case SQL_ATTR_ROW_ARRAY_SIZE : _SQLSetARDField ( & ( ( ( pODBCStmt ) pStmt ) -> ARD ), SQL_DESC_ARRAY_SIZE, pDataPtr, pDataSize ); break; case SQL_ATTR_ROW_BIND_OFFSET_PTR : _SQLSetARDField ( & ( ( ( pODBCStmt ) pStmt ) -> ARD ), SQL_DESC_BIND_OFFSET_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_ROW_BIND_TYPE : _SQLSetARDField ( & ( ( ( pODBCStmt ) pStmt ) -> ARD ), SQL_DESC_BIND_TYPE, pDataPtr, pDataSize ); break; case SQL_ATTR_ROW_OPERATION_PTR : _SQLSetARDField ( & ( ( ( pODBCStmt ) pStmt ) -> ARD ), SQL_DESC_ARRAY_STATUS_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_ROW_STATUS_PTR : _SQLSetIRDField ( & ( ( ( pODBCStmt ) pStmt ) -> IRD ), SQL_DESC_ARRAY_STATUS_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_ROWS_FETCHED_PTR : _SQLSetIRDField ( & ( ( ( pODBCStmt ) pStmt ) -> IRD ), SQL_DESC_ROWS_PROCESSED_PTR, pDataPtr, pDataSize ); break; case SQL_ATTR_SIMULATE_CURSOR : __ODBCPOPMSG ( _ODBCPopMsg ( "SQL_ATTR_SIMULATE_CURSOR - option not implemented" ) ); return SQL_ERROR; default : __ODBCPOPMSG ( _ODBCPopMsg ( "SQLSetStmtAttr: Stmt attr - unknown %d", pAttr ) ); return SQL_ERROR; } return SQL_SUCCESS; }