connectivity/source/drivers/odbcbase/ODatabaseMetaDataResultSet.cxx | 85 ++------ connectivity/source/drivers/odbcbase/OResultSet.cxx | 75 +++---- connectivity/source/drivers/odbcbase/OStatement.cxx | 100 +++------- connectivity/source/drivers/odbcbase/OTools.cxx | 93 +++++++++ connectivity/source/inc/odbc/ODatabaseMetaDataResultSet.hxx | 2 connectivity/source/inc/odbc/OResultSet.hxx | 2 connectivity/source/inc/odbc/OStatement.hxx | 3 7 files changed, 203 insertions(+), 157 deletions(-)
New commits: commit 19ef5bcc8d9dbcf965f79495e1afd86ac0f22c31 Author: Lionel Elie Mamane <lio...@mamane.lu> Date: Tue Jan 24 22:21:41 2012 +0100 use proper sizes for SQL(Get|Set)StmtAttr Fixes fdo#34432 (driver smashes our stack) Continuation of commit 9a466d9718cceeb4ace9e3352a173c7b62387eee Author: Lionel Elie Mamane <lio...@mamane.lu> Date: Tue Nov 29 17:49:36 2011 +0100 ODBC: use right integer length to get Statement Options diff --git a/connectivity/source/drivers/odbcbase/OResultSet.cxx b/connectivity/source/drivers/odbcbase/OResultSet.cxx index 1787744..a882c21 100644 --- a/connectivity/source/drivers/odbcbase/OResultSet.cxx +++ b/connectivity/source/drivers/odbcbase/OResultSet.cxx @@ -118,15 +118,15 @@ OResultSet::OResultSet(SQLHANDLE _pStatementHandle ,OStatement_Base* pStmt) : try { m_pRowStatusArray = new SQLUSMALLINT[1]; // the default value - N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_STATUS_PTR,m_pRowStatusArray,SQL_IS_POINTER); + setStmtOption<SQLUSMALLINT*, SQL_IS_POINTER>(SQL_ATTR_ROW_STATUS_PTR, m_pRowStatusArray); } catch(const Exception&) { // we don't want our result destroy here } - SQLINTEGER nCurType = 0; + SQLULEN nCurType = 0; try { - N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,&nCurType,SQL_IS_UINTEGER,0); + nCurType = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE); SQLUINTEGER nValueLen = m_pStatement->getCursorProperties(nCurType,sal_False); if( (nValueLen & SQL_CA2_SENSITIVITY_DELETIONS) != SQL_CA2_SENSITIVITY_DELETIONS || (nValueLen & SQL_CA2_CRC_EXACT) != SQL_CA2_CRC_EXACT) @@ -841,9 +841,10 @@ void SAL_CALL OResultSet::insertRow( ) throw(SQLException, RuntimeException) checkDisposed(OResultSet_BASE::rBHelper.bDisposed); - SQLLEN nMaxLen = 20; + const SQLLEN nMaxLen = 20; SQLLEN nRealLen = 0; Sequence<sal_Int8> aBookmark(nMaxLen); + assert (static_cast<size_t>(nMaxLen) >= sizeof(SQLLEN)); SQLRETURN nRet = N3SQLBindCol(m_aStatementHandle, 0, @@ -880,7 +881,7 @@ void SAL_CALL OResultSet::insertRow( ) throw(SQLException, RuntimeException) if ( bPositionByBookmark ) { - nRet = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_FETCH_BOOKMARK_PTR,aBookmark.getArray(),SQL_IS_POINTER); // SQL_LEN_BINARY_ATTR(aBookmark.getLength()) + setStmtOption<SQLLEN*, SQL_IS_POINTER>(SQL_ATTR_FETCH_BOOKMARK_PTR, reinterpret_cast<SQLLEN*>(aBookmark.getArray())); nRet = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_BOOKMARK,0); } @@ -1156,10 +1157,7 @@ Any SAL_CALL OResultSet::getBookmark( ) throw( SQLException, RuntimeException) { if ( m_nUseBookmarks == ODBC_SQL_NOT_DEFINED ) { - RTL_LOGFILE_CONTEXT_TRACE( aLogger, "SQLGetStmtAttr" ); - m_nUseBookmarks = SQL_UB_OFF; - SQLRETURN nRet = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,&m_nUseBookmarks,SQL_IS_UINTEGER,NULL); - OSL_UNUSED( nRet ); + m_nUseBookmarks = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, SQL_UB_OFF); } if(m_nUseBookmarks == SQL_UB_OFF) throw SQLException(); @@ -1184,8 +1182,7 @@ sal_Bool SAL_CALL OResultSet::moveToBookmark( const Any& bookmark ) throw( SQLE OSL_ENSURE(m_aBookmark.getLength(),"Invalid bookmark from length 0!"); if(m_aBookmark.getLength()) { - SQLRETURN nReturn = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_FETCH_BOOKMARK_PTR,m_aBookmark.getArray(),SQL_IS_POINTER); // SQL_LEN_BINARY_ATTR(aBookmark.getLength()) - OSL_UNUSED( nReturn ); + SQLRETURN nReturn = setStmtOption<SQLLEN*, SQL_IS_POINTER>(SQL_ATTR_FETCH_BOOKMARK_PTR, reinterpret_cast<SQLLEN*>(m_aBookmark.getArray())); if ( SQL_INVALID_HANDLE != nReturn && SQL_ERROR != nReturn ) { @@ -1211,7 +1208,7 @@ sal_Bool SAL_CALL OResultSet::moveRelativeToBookmark( const Any& bookmark, sal_ m_nLastColumnPos = 0; bookmark >>= m_aBookmark; - SQLRETURN nReturn = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_FETCH_BOOKMARK_PTR,m_aBookmark.getArray(),SQL_IS_POINTER); + SQLRETURN nReturn = setStmtOption<SQLLEN*, SQL_IS_POINTER>(SQL_ATTR_FETCH_BOOKMARK_PTR, reinterpret_cast<SQLLEN*>(m_aBookmark.getArray())); OSL_UNUSED( nReturn ); m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_BOOKMARK,rows); @@ -1266,11 +1263,23 @@ Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& return aRet; } //------------------------------------------------------------------------------ +template < typename T, SQLINTEGER BufferLength > T OResultSet::getStmtOption (SQLINTEGER fOption, T dflt) const +{ + T result (dflt); + OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); + N3SQLGetStmtAttr(m_aStatementHandle, fOption, &result, BufferLength, NULL); + return result; +} +template < typename T, SQLINTEGER BufferLength > SQLRETURN OResultSet::setStmtOption (SQLINTEGER fOption, T value) const +{ + OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); + SQLPOINTER sv = reinterpret_cast<SQLPOINTER>(value); + return N3SQLSetStmtAttr(m_aStatementHandle, fOption, sv, BufferLength); +} +//------------------------------------------------------------------------------ sal_Int32 OResultSet::getResultSetConcurrency() const { - sal_uInt32 nValue = 0; - SQLRETURN nReturn = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CONCURRENCY,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nReturn ); + sal_uInt32 nValue = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY); if(SQL_CONCUR_READ_ONLY == nValue) nValue = ResultSetConcurrency::READ_ONLY; else @@ -1281,16 +1290,14 @@ sal_Int32 OResultSet::getResultSetConcurrency() const //------------------------------------------------------------------------------ sal_Int32 OResultSet::getResultSetType() const { - sal_uInt32 nValue = 0; - N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SENSITIVITY,&nValue,SQL_IS_UINTEGER,0); + sal_uInt32 nValue = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SENSITIVITY); if(SQL_SENSITIVE == nValue) nValue = ResultSetType::SCROLL_SENSITIVE; else if(SQL_INSENSITIVE == nValue) nValue = ResultSetType::SCROLL_INSENSITIVE; else { - SQLINTEGER nCurType = 0; - N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,&nCurType,SQL_IS_UINTEGER,0); + SQLULEN nCurType = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE); if(SQL_CURSOR_KEYSET_DRIVEN == nCurType) nValue = ResultSetType::SCROLL_SENSITIVE; else if(SQL_CURSOR_STATIC == nCurType) @@ -1310,9 +1317,7 @@ sal_Int32 OResultSet::getFetchDirection() const //------------------------------------------------------------------------------ sal_Int32 OResultSet::getFetchSize() const { - sal_uInt32 nValue = 0; - N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,&nValue,SQL_IS_UINTEGER,0); - return nValue; + return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE); } //------------------------------------------------------------------------------ ::rtl::OUString OResultSet::getCursorName() const @@ -1328,13 +1333,12 @@ sal_Bool OResultSet::isBookmarkable() const if(!m_aConnectionHandle) return sal_False; - sal_uInt32 nValue = 0; - N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,&nValue,SQL_IS_UINTEGER,0); + const SQLULEN nCursorType = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE); sal_Int32 nAttr = 0; try { - switch(nValue) + switch(nCursorType) { case SQL_CURSOR_FORWARD_ONLY: return sal_False; @@ -1356,9 +1360,7 @@ sal_Bool OResultSet::isBookmarkable() const if ( m_nUseBookmarks == ODBC_SQL_NOT_DEFINED ) { - m_nUseBookmarks = SQL_UB_OFF; - SQLRETURN nRet = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,&m_nUseBookmarks,SQL_IS_UINTEGER,NULL); - OSL_UNUSED( nRet ); + m_nUseBookmarks = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, SQL_UB_OFF); } return (m_nUseBookmarks != SQL_UB_OFF) && (nAttr & SQL_CA1_BOOKMARK) == SQL_CA1_BOOKMARK; @@ -1369,7 +1371,7 @@ void OResultSet::setFetchDirection(sal_Int32 _par0) OSL_ENSURE(_par0>0,"Illegal fetch direction!"); if ( _par0 > 0 ) { - N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)(sal_IntPtr)_par0,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, _par0); } } //------------------------------------------------------------------------------ @@ -1378,11 +1380,11 @@ void OResultSet::setFetchSize(sal_Int32 _par0) OSL_ENSURE(_par0>0,"Illegal fetch size!"); if ( _par0 > 0 ) { - N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,(SQLPOINTER)(sal_IntPtr)_par0,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE, _par0); delete [] m_pRowStatusArray; m_pRowStatusArray = new SQLUSMALLINT[_par0]; - N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_STATUS_PTR,m_pRowStatusArray,SQL_IS_POINTER); + setStmtOption<SQLUSMALLINT*, SQL_IS_POINTER>(SQL_ATTR_ROW_STATUS_PTR, m_pRowStatusArray); } } // ------------------------------------------------------------------------- @@ -1656,10 +1658,7 @@ sal_Bool OResultSet::move(IResultSetHelper::Movement _eCursorPosition, sal_Int32 } // switch(_eCursorPosition) if ( m_nUseBookmarks == ODBC_SQL_NOT_DEFINED ) { - RTL_LOGFILE_CONTEXT_TRACE( aLogger, "SQLGetStmtAttr" ); - m_nUseBookmarks = SQL_UB_OFF; - SQLRETURN nRet = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,&m_nUseBookmarks,SQL_IS_UINTEGER,NULL); - OSL_UNUSED( nRet ); + m_nUseBookmarks = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, SQL_UB_OFF); } if ( m_nUseBookmarks != SQL_UB_OFF ) { @@ -1679,10 +1678,8 @@ sal_Bool OResultSet::move(IResultSetHelper::Movement _eCursorPosition, sal_Int32 // ----------------------------------------------------------------------------- sal_Int32 OResultSet::getDriverPos() const { - sal_Int32 nValue = 0; - SQLRETURN nRet = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_NUMBER,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nRet ); - OSL_TRACE( __FILE__": OResultSet::getDriverPos() = Ret = %d, RowNum = %d, RowPos = %d",nRet,nValue , m_nRowPos); + sal_Int32 nValue = getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_NUMBER); + OSL_TRACE( __FILE__": OResultSet::getDriverPos() = RowNum = %d, RowPos = %d", nValue, m_nRowPos); return nValue ? nValue : m_nRowPos; } // ----------------------------------------------------------------------------- diff --git a/connectivity/source/drivers/odbcbase/OStatement.cxx b/connectivity/source/drivers/odbcbase/OStatement.cxx index d268b2f..27eec15 100644 --- a/connectivity/source/drivers/odbcbase/OStatement.cxx +++ b/connectivity/source/drivers/odbcbase/OStatement.cxx @@ -300,8 +300,7 @@ sal_Bool OStatement_Base::lockIfNecessary (const ::rtl::OUString& sql) throw( SQ OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); try { - SQLINTEGER nLock = SQL_CONCUR_LOCK; - THROW_SQL(N3SQLSetStmtAttr(m_aStatementHandle, SQL_CONCURRENCY,(SQLPOINTER)(sal_IntPtr)nLock,SQL_IS_UINTEGER)); + THROW_SQL((setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY, SQL_CONCUR_LOCK))); } catch (const SQLWarning& warn) { @@ -446,13 +445,19 @@ Reference< XResultSet > OStatement_Base::getResultSet (sal_Bool checkCount) thro // Invoke SQLGetStmtOption with the given option. //-------------------------------------------------------------------- -template < typename T, SQLINTEGER BufferLength > T OStatement_Base::getStmtOption (short fOption) const +template < typename T, SQLINTEGER BufferLength > T OStatement_Base::getStmtOption (SQLINTEGER fOption, T dflt) const { - T result = 0; + T result (dflt); OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); N3SQLGetStmtAttr(m_aStatementHandle, fOption, &result, BufferLength, NULL); return result; } +template < typename T, SQLINTEGER BufferLength > SQLRETURN OStatement_Base::setStmtOption (SQLINTEGER fOption, T value) const +{ + OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); + SQLPOINTER sv = reinterpret_cast<SQLPOINTER>(value); + return N3SQLSetStmtAttr(m_aStatementHandle, fOption, sv, BufferLength); +} // ------------------------------------------------------------------------- Reference< XResultSet > SAL_CALL OStatement_Base::executeQuery( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException) @@ -676,16 +681,13 @@ sal_Int64 OStatement_Base::getQueryTimeOut() const //------------------------------------------------------------------------------ sal_Int64 OStatement_Base::getMaxRows() const { - // How do I say I want a SQLULEN?? return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_ROWS); } //------------------------------------------------------------------------------ sal_Int32 OStatement_Base::getResultSetConcurrency() const { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uInt32 nValue; - SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CONCURRENCY,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nRetCode ); + SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY)); if(nValue == SQL_CONCUR_READ_ONLY) nValue = ResultSetConcurrency::READ_ONLY; else @@ -696,10 +698,7 @@ sal_Int32 OStatement_Base::getResultSetConcurrency() const sal_Int32 OStatement_Base::getResultSetType() const { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uInt32 nValue = SQL_CURSOR_FORWARD_ONLY; - SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SENSITIVITY,&nValue,SQL_IS_UINTEGER,0); - nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nRetCode ); + SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY)); switch(nValue) { case SQL_CURSOR_FORWARD_ONLY: @@ -712,6 +711,8 @@ sal_Int32 OStatement_Base::getResultSetType() const case SQL_CURSOR_DYNAMIC: nValue = ResultSetType::SCROLL_SENSITIVE; break; + default: + OSL_FAIL("Unknown ODBC Cursor Type"); } return nValue; @@ -720,10 +721,7 @@ sal_Int32 OStatement_Base::getResultSetType() const sal_Int32 OStatement_Base::getFetchDirection() const { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uInt32 nValue = 0; - SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nRetCode ); - + SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE)); switch(nValue) { case SQL_SCROLLABLE: @@ -740,10 +738,7 @@ sal_Int32 OStatement_Base::getFetchDirection() const sal_Int32 OStatement_Base::getFetchSize() const { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uInt32 nValue; - SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,&nValue,SQL_IS_UINTEGER,0); - OSL_UNUSED( nRetCode ); - return nValue; + return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE); } //------------------------------------------------------------------------------ sal_Int64 OStatement_Base::getMaxFieldSize() const @@ -764,39 +759,35 @@ sal_Int64 OStatement_Base::getMaxFieldSize() const void OStatement_Base::setQueryTimeOut(sal_Int32 seconds) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_QUERY_TIMEOUT,(SQLPOINTER)(sal_IntPtr)seconds,SQL_IS_UINTEGER); - OSL_UNUSED( nRetCode ); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_QUERY_TIMEOUT,seconds); } //------------------------------------------------------------------------------ void OStatement_Base::setMaxRows(sal_Int32 _par0) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_MAX_ROWS, (SQLPOINTER)(sal_IntPtr)_par0,SQL_IS_UINTEGER); - OSL_UNUSED( nRetCode ); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_ROWS, _par0); } //------------------------------------------------------------------------------ void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0) { - SQLINTEGER nSet; + SQLULEN nSet; if(_par0 == ResultSetConcurrency::READ_ONLY) nSet = SQL_CONCUR_READ_ONLY; else nSet = SQL_CONCUR_VALUES; OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CONCURRENCY,(SQLPOINTER)(sal_IntPtr)nSet,SQL_IS_UINTEGER); - + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY, nSet); } //------------------------------------------------------------------------------ void OStatement_Base::setResultSetType(sal_Int32 _par0) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_ROW_BIND_TYPE,(SQLPOINTER)SQL_BIND_BY_COLUMN,SQL_IS_UINTEGER); - OSL_UNUSED( nRetCode ); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_BIND_TYPE, SQL_BIND_BY_COLUMN); sal_Bool bUseBookmark = isUsingBookmarks(); - SQLUINTEGER nSet( SQL_UNSPECIFIED ); + SQLULEN nSet( SQL_UNSPECIFIED ); switch(_par0) { case ResultSetType::FORWARD_ONLY: @@ -804,7 +795,7 @@ void OStatement_Base::setResultSetType(sal_Int32 _par0) break; case ResultSetType::SCROLL_INSENSITIVE: nSet = SQL_INSENSITIVE; - N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, SQL_CURSOR_KEYSET_DRIVEN); break; case ResultSetType::SCROLL_SENSITIVE: if(bUseBookmark) @@ -830,47 +821,41 @@ void OStatement_Base::setResultSetType(sal_Int32 _par0) } else nSet = SQL_CURSOR_DYNAMIC; - if(N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)(sal_uIntPtr)nSet,SQL_IS_UINTEGER) != SQL_SUCCESS) + if( setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, nSet) != SQL_SUCCESS ) { - nSet = SQL_CURSOR_KEYSET_DRIVEN; - N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)(sal_uIntPtr)nSet,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, SQL_CURSOR_KEYSET_DRIVEN); } nSet = SQL_SENSITIVE; break; default: + fprintf(stderr, "_par0=%d\n", _par0); OSL_FAIL( "OStatement_Base::setResultSetType: invalid result set type!" ); break; } - N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_SENSITIVITY,(SQLPOINTER)(sal_uIntPtr)nSet,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SENSITIVITY, nSet); } //------------------------------------------------------------------------------ void OStatement_Base::setEscapeProcessing( const sal_Bool _bEscapeProc ) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - SQLUINTEGER nEscapeProc( _bEscapeProc ? SQL_NOSCAN_OFF : SQL_NOSCAN_ON ); - SQLRETURN nRetCode = N3SQLSetStmtAttr( m_aStatementHandle, SQL_ATTR_NOSCAN, (SQLPOINTER)(sal_uIntPtr)nEscapeProc, SQL_IS_UINTEGER ); - (void)nRetCode; + SQLULEN nEscapeProc( _bEscapeProc ? SQL_NOSCAN_OFF : SQL_NOSCAN_ON ); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_NOSCAN, nEscapeProc); } //------------------------------------------------------------------------------ void OStatement_Base::setFetchDirection(sal_Int32 _par0) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_IntPtr nCursType = 0; - SQLRETURN nRetCode = SQL_SUCCESS; if(_par0 == FetchDirection::FORWARD) { - nCursType = SQL_NONSCROLLABLE; - nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,(SQLPOINTER)nCursType,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE, SQL_NONSCROLLABLE); } else if(_par0 == FetchDirection::REVERSE) { - nCursType = SQL_SCROLLABLE; - nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,(SQLPOINTER)nCursType,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE, SQL_SCROLLABLE); } - OSL_UNUSED( nRetCode ); } //------------------------------------------------------------------------------ void OStatement_Base::setFetchSize(sal_Int32 _par0) @@ -879,19 +864,19 @@ void OStatement_Base::setFetchSize(sal_Int32 _par0) OSL_ENSURE(_par0>0,"Illegal fetch size!"); if ( _par0 > 0 ) { - SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,(SQLPOINTER)(sal_IntPtr)_par0,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE, _par0); - delete m_pRowStatusArray; + if (m_pRowStatusArray) + delete[] m_pRowStatusArray; m_pRowStatusArray = new SQLUSMALLINT[_par0]; - nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_STATUS_PTR,m_pRowStatusArray,SQL_IS_POINTER); - OSL_UNUSED( nRetCode ); + setStmtOption<SQLUSMALLINT*, SQL_IS_POINTER>(SQL_ATTR_ROW_STATUS_PTR, m_pRowStatusArray); } } //------------------------------------------------------------------------------ void OStatement_Base::setMaxFieldSize(sal_Int32 _par0) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_MAX_LENGTH,(SQLPOINTER)(sal_IntPtr)_par0,SQL_IS_UINTEGER); + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_LENGTH, _par0); } //------------------------------------------------------------------------------ void OStatement_Base::setCursorName(const ::rtl::OUString &_par0) @@ -904,27 +889,20 @@ void OStatement_Base::setCursorName(const ::rtl::OUString &_par0) sal_Bool OStatement_Base::isUsingBookmarks() const { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uInt32 nValue = SQL_UB_OFF; - SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,&nValue,SQL_IS_UINTEGER,NULL); - OSL_UNUSED( nRetCode ); - return nValue != SQL_UB_OFF; + return SQL_UB_OFF != getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, SQL_UB_OFF); } // ------------------------------------------------------------------------- sal_Bool OStatement_Base::getEscapeProcessing() const { OSL_ENSURE( m_aStatementHandle, "StatementHandle is null!" ); - sal_uInt32 nValue = SQL_NOSCAN_OFF; - SQLRETURN nRetCode = N3SQLGetStmtAttr( m_aStatementHandle, SQL_ATTR_NOSCAN, &nValue, SQL_IS_UINTEGER, NULL ); - (void)nRetCode; - return nValue == SQL_NOSCAN_OFF; + return SQL_NOSCAN_OFF == getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, SQL_NOSCAN_OFF);; } // ------------------------------------------------------------------------- void OStatement_Base::setUsingBookmarks(sal_Bool _bUseBookmark) { OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!"); - sal_uIntPtr nValue = _bUseBookmark ? SQL_UB_VARIABLE : SQL_UB_OFF; - SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,(SQLPOINTER)nValue,SQL_IS_UINTEGER); - OSL_UNUSED( nRetCode ); + SQLULEN nValue = _bUseBookmark ? SQL_UB_VARIABLE : SQL_UB_OFF; + setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, nValue); } // ------------------------------------------------------------------------- ::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const diff --git a/connectivity/source/inc/odbc/OResultSet.hxx b/connectivity/source/inc/odbc/OResultSet.hxx index bbb3920..e036225 100644 --- a/connectivity/source/inc/odbc/OResultSet.hxx +++ b/connectivity/source/inc/odbc/OResultSet.hxx @@ -160,9 +160,11 @@ namespace connectivity sal_Int32 getFetchDirection() const; sal_Int32 getFetchSize() const; ::rtl::OUString getCursorName() const; + template < typename T, SQLINTEGER BufferLength > T getStmtOption (SQLINTEGER fOption, T dflt = 0) const; void setFetchDirection(sal_Int32 _par0); void setFetchSize(sal_Int32 _par0); + template < typename T, SQLINTEGER BufferLength > SQLRETURN setStmtOption (SQLINTEGER fOption, T value) const; void fillRow(sal_Int32 _nToColumn); diff --git a/connectivity/source/inc/odbc/OStatement.hxx b/connectivity/source/inc/odbc/OStatement.hxx index 2ad1a42..e0d4663 100644 --- a/connectivity/source/inc/odbc/OStatement.hxx +++ b/connectivity/source/inc/odbc/OStatement.hxx @@ -97,7 +97,7 @@ namespace connectivity ::rtl::OUString getCursorName() const; sal_Bool isUsingBookmarks() const; sal_Bool getEscapeProcessing() const; - template < typename T, SQLINTEGER BufferLength > T getStmtOption (short fOption) const; + template < typename T, SQLINTEGER BufferLength > T getStmtOption (SQLINTEGER fOption, T dflt = 0) const; void setQueryTimeOut(sal_Int32 _par0) ; void setMaxFieldSize(sal_Int32 _par0) ; @@ -106,6 +106,7 @@ namespace connectivity void setFetchSize(sal_Int32 _par0) ; void setCursorName(const ::rtl::OUString &_par0); void setEscapeProcessing( const sal_Bool _bEscapeProc ); + template < typename T, SQLINTEGER BufferLength > SQLRETURN setStmtOption (SQLINTEGER fOption, T value) const; virtual void setResultSetConcurrency(sal_Int32 _par0) ; virtual void setResultSetType(sal_Int32 _par0) ; commit 63b6b1d6120d82c4baf5cb679d75dcc5427dbbc3 Author: Lionel Elie Mamane <lio...@mamane.lu> Date: Tue Jan 24 22:20:31 2012 +0100 make OTools::getValue insanely safe, factorise get{Int,Long,Byte,...} diff --git a/connectivity/source/drivers/odbcbase/ODatabaseMetaDataResultSet.cxx b/connectivity/source/drivers/odbcbase/ODatabaseMetaDataResultSet.cxx index 59876bb..6dd7881 100644 --- a/connectivity/source/drivers/odbcbase/ODatabaseMetaDataResultSet.cxx +++ b/connectivity/source/drivers/odbcbase/ODatabaseMetaDataResultSet.cxx @@ -170,6 +170,30 @@ sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::findColumn( const ::rtl::OUString break; return i; } + +template < typename T, SQLSMALLINT sqlTypeId > T ODatabaseMetaDataResultSet::getInteger ( sal_Int32 columnIndex ) +{ + checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); + ::osl::MutexGuard aGuard( m_aMutex ); + + columnIndex = mapColumn(columnIndex); + T nVal = 0; + if(columnIndex <= m_nDriverColumnCount) + { + getValue<T>(m_pConnection, m_aStatementHandle, columnIndex, sqlTypeId, m_bWasNull, **this, nVal); + + if ( !m_aValueRange.empty() ) + { + ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter (m_aValueRange.find(columnIndex)); + if ( aValueRangeIter != m_aValueRange.end() ) + return static_cast<T>(aValueRangeIter->second[nVal]); + } + } + else + m_bWasNull = sal_True; + return nVal; +} + // ------------------------------------------------------------------------- Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) { @@ -215,24 +239,7 @@ sal_Bool SAL_CALL ODatabaseMetaDataResultSet::getBoolean( sal_Int32 columnIndex sal_Int8 SAL_CALL ODatabaseMetaDataResultSet::getByte( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) { - - checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); - ::osl::MutexGuard aGuard( m_aMutex ); - - - columnIndex = mapColumn(columnIndex); - sal_Int8 nVal = 0; - if(columnIndex <= m_nDriverColumnCount) - { - OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_TINYINT,m_bWasNull,**this,&nVal,sizeof nVal); - - ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; - if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) - return sal_Int8((*aValueRangeIter).second[(sal_Int32)nVal]); - } - else - m_bWasNull = sal_True; - return nVal; + return getInteger<sal_Int8, SQL_C_STINYINT>( columnIndex ); } // ------------------------------------------------------------------------- @@ -322,24 +329,7 @@ float SAL_CALL ODatabaseMetaDataResultSet::getFloat( sal_Int32 columnIndex ) thr sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getInt( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) { - - checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); - ::osl::MutexGuard aGuard( m_aMutex ); - - - columnIndex = mapColumn(columnIndex); - sal_Int32 nVal = 0; - if(columnIndex <= m_nDriverColumnCount) - { - OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_LONG,m_bWasNull,**this,&nVal,sizeof nVal); - - ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; - if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) - return (*aValueRangeIter).second[(sal_Int32)nVal]; - } - else - m_bWasNull = sal_True; - return nVal; + return getInteger<sal_Int32, SQL_C_SLONG>( columnIndex ); } // ------------------------------------------------------------------------- @@ -349,10 +339,9 @@ sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getRow( ) throw(SQLException, Ru } // ------------------------------------------------------------------------- -sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) +sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) { - ::dbtools::throwFunctionNotSupportedException( "XRow::getLong", *this ); - return 0; + return getInteger<sal_Int64, SQL_C_SBIGINT>( columnIndex ); } // ------------------------------------------------------------------------- @@ -398,23 +387,7 @@ Any SAL_CALL ODatabaseMetaDataResultSet::getObject( sal_Int32 /*columnIndex*/, c sal_Int16 SAL_CALL ODatabaseMetaDataResultSet::getShort( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) { - - checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); - ::osl::MutexGuard aGuard( m_aMutex ); - - columnIndex = mapColumn(columnIndex); - sal_Int16 nVal = 0; - if(columnIndex <= m_nDriverColumnCount) - { - OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_SHORT,m_bWasNull,**this,&nVal,sizeof nVal); - - ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; - if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) - return sal_Int16((*aValueRangeIter).second[(sal_Int32)nVal]); - } - else - m_bWasNull = sal_True; - return nVal; + return getInteger<sal_Int16, SQL_C_SSHORT>( columnIndex ); } // ------------------------------------------------------------------------- diff --git a/connectivity/source/drivers/odbcbase/OTools.cxx b/connectivity/source/drivers/odbcbase/OTools.cxx index 4da70ef..9e8714c 100644 --- a/connectivity/source/drivers/odbcbase/OTools.cxx +++ b/connectivity/source/drivers/odbcbase/OTools.cxx @@ -45,6 +45,82 @@ using namespace com::sun::star::uno; using namespace com::sun::star::sdbc; using namespace com::sun::star::util; +namespace { +size_t sqlTypeLen ( SQLSMALLINT _nType ) +{ + switch (_nType) + { + case SQL_C_CHAR: + return sizeof(SQLCHAR *); + case SQL_C_WCHAR: + return sizeof(SQLWCHAR *); + case SQL_C_SSHORT: + case SQL_C_SHORT: + return sizeof(SQLSMALLINT); + case SQL_C_USHORT: + return sizeof(SQLUSMALLINT); + case SQL_C_SLONG: + case SQL_C_LONG: + return sizeof(SQLINTEGER); + case SQL_C_ULONG: + return sizeof(SQLUINTEGER); + case SQL_C_FLOAT: + return sizeof(SQLREAL); + case SQL_C_DOUBLE: + OSL_ENSURE(sizeof(SQLDOUBLE) == sizeof(SQLFLOAT), "SQLDOUBLE/SQLFLOAT confusion"); + return sizeof(SQLDOUBLE); + case SQL_C_BIT: + return sizeof(SQLCHAR); + case SQL_C_STINYINT: + case SQL_C_TINYINT: + return sizeof(SQLSCHAR); + case SQL_C_UTINYINT: + return sizeof(SQLCHAR); + case SQL_C_SBIGINT: + return sizeof(SQLBIGINT); + case SQL_C_UBIGINT: + return sizeof(SQLUBIGINT); + /* UnixODBC gives this the same value as SQL_C_UBIGINT + case SQL_C_BOOKMARK: + return sizeof(BOOKMARK); */ + case SQL_C_BINARY: + // UnixODBC gives these the same value + //case SQL_C_VARBOOKMARK: + return sizeof(SQLCHAR*); + case SQL_C_TYPE_DATE: + case SQL_C_DATE: + return sizeof(SQL_DATE_STRUCT); + case SQL_C_TYPE_TIME: + case SQL_C_TIME: + return sizeof(SQL_TIME_STRUCT); + case SQL_C_TYPE_TIMESTAMP: + case SQL_C_TIMESTAMP: + return sizeof(SQL_TIMESTAMP_STRUCT); + case SQL_C_NUMERIC: + return sizeof(SQL_NUMERIC_STRUCT); + case SQL_C_GUID: + return sizeof(SQLGUID); + case SQL_C_INTERVAL_YEAR: + case SQL_C_INTERVAL_MONTH: + case SQL_C_INTERVAL_DAY: + case SQL_C_INTERVAL_HOUR: + case SQL_C_INTERVAL_MINUTE: + case SQL_C_INTERVAL_SECOND: + case SQL_C_INTERVAL_YEAR_TO_MONTH: + case SQL_C_INTERVAL_DAY_TO_HOUR: + case SQL_C_INTERVAL_DAY_TO_MINUTE: + case SQL_C_INTERVAL_DAY_TO_SECOND: + case SQL_C_INTERVAL_HOUR_TO_MINUTE: + case SQL_C_INTERVAL_HOUR_TO_SECOND: + case SQL_C_INTERVAL_MINUTE_TO_SECOND: + return sizeof(SQL_INTERVAL_STRUCT); + default: + return static_cast<size_t>(-1); + } +} +} + + void OTools::getValue( OConnection* _pConnection, SQLHANDLE _aStatementHandle, sal_Int32 columnIndex, @@ -55,6 +131,23 @@ void OTools::getValue( OConnection* _pConnection, SQLLEN _nSize) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "odbc", "ocke.jans...@sun.com", "OTools::getValue" ); + const size_t properSize = sqlTypeLen(_nType); + if ( properSize == static_cast<size_t>(-1) ) + OSL_FAIL("connectivity::odbc::OTools::getValue: unknown SQL type - cannot check buffer size"); + else + { + OSL_ENSURE(static_cast<size_t>(_nSize) == properSize, "connectivity::odbc::OTools::getValue got wrongly sized memory region to write result to"); + if ( static_cast<size_t>(_nSize) > properSize ) + { + OSL_FAIL("memory region is too big - trying to fudge it"); + memset(_pValue, 0, _nSize); +#ifdef OSL_BIGENDIAN + // This is skewed in favour of integer types + _pValue += _nSize - properSize; +#endif + } + } + OSL_ENSURE(static_cast<size_t>(_nSize) >= properSize, "memory region is too small"); SQLLEN pcbValue = SQL_NULL_DATA; OTools::ThrowException(_pConnection, (*(T3SQLGetData)_pConnection->getOdbcFunction(ODBC3SQLGetData))(_aStatementHandle, diff --git a/connectivity/source/inc/odbc/ODatabaseMetaDataResultSet.hxx b/connectivity/source/inc/odbc/ODatabaseMetaDataResultSet.hxx index 1ae6042..7a17249 100644 --- a/connectivity/source/inc/odbc/ODatabaseMetaDataResultSet.hxx +++ b/connectivity/source/inc/odbc/ODatabaseMetaDataResultSet.hxx @@ -125,6 +125,8 @@ namespace connectivity sal_Int32 nHandle ) const; ~ODatabaseMetaDataResultSet(); + template < typename T, SQLSMALLINT sqlTypeId > T getInteger ( sal_Int32 columnIndex ); + public: // ein Konstruktor, der fuer das Returnen des Objektes benoetigt wird: ODatabaseMetaDataResultSet(OConnection* _pConnection); _______________________________________________ Libreoffice-commits mailing list Libreoffice-commits@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/libreoffice-commits