/************************************************************************* * * $RCSfile: KeySet.cxx,v $ * * $Revision: 1.9 $ * * last change: $Author: oj $ $Date: 2001-01-30 14:27:46 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ #ifndef DBACCESS_CORE_API_KEYSET_HXX #include "KeySet.hxx" #endif #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_XPREPAREDSTATEMENT_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCxParameterS_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_XCOLUMNLOCATE_HPP_ #include #endif #ifndef _COM_SUN_STAR_CONTAINER_XINDEXACCESS_HPP_ #include #endif #ifndef DBACCESS_SHARED_DBASTRINGS_HRC #include "dbastrings.hrc" #endif #ifndef _DBASHARED_APITOOLS_HXX_ #include "apitools.hxx" #endif #ifndef _COM_SUN_STAR_SDBCX_XKEYSSUPPLIER_HPP_ #include #endif #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_ #include #endif #ifndef _COMPHELPER_TYPES_HXX_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_KEYTYPE_HPP_ #include #endif using namespace dbaccess; using namespace connectivity; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::sdb; using namespace ::com::sun::star::sdbcx; using namespace ::com::sun::star::container; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::util; using namespace ::cppu; using namespace ::osl; // ------------------------------------------------------------------------- OKeySet::OKeySet(const Reference< XResultSet>& _xDriverSet, const connectivity::OSQLTable& _xTable, const Reference< XSQLQueryComposer >& _xComposer) : OCacheSet(_xDriverSet) ,m_xTable(_xTable) ,m_bRowCountFinal(sal_False) { try { m_aColumnNames = getColumnNames(); sal_Int32 nSize = m_aColumnNames.size(); Reference xColumnLocate(_xDriverSet,UNO_QUERY); if(xColumnLocate.is()) { ::std::vector< ::rtl::OUString>::const_iterator aIter; for(aIter = m_aColumnNames.begin();aIter != m_aColumnNames.end();++aIter) m_aColumnPos.push_back(xColumnLocate->findColumn(*aIter)); } else { Reference xTableProp(_xTable,UNO_QUERY); ::std::vector< ::rtl::OUString>::const_iterator aIter; ::comphelper::UStringMixEqual bCase(m_xConnection->getMetaData()->storesMixedCaseQuotedIdentifiers()); sal_Int32 nColumnCount = m_xSetMetaData->getColumnCount(); for(sal_Int32 i=1;i<=nColumnCount;++i) { for(aIter = m_aColumnNames.begin();aIter != m_aColumnNames.end();++aIter) { if(bCase(m_xSetMetaData->getColumnName(i),*aIter) && bCase(m_xSetMetaData->getTableName(i),connectivity::getString(xTableProp->getPropertyValue(PROPERTY_NAME)))) { m_aColumnPos.push_back(i); break; } } } } OSL_ENSURE(m_aColumnPos.size() == nSize,"Error not all pkey columns are found!"); // the first row is empty because it's now easier for us to distinguish when we are beforefirst or first // without extra varaible to be set m_aKeyMap.insert(OKeySetMatrix::value_type(0,NULL)); m_aKeyIter = m_aKeyMap.begin(); static ::rtl::OUString aAnd = ::rtl::OUString::createFromAscii(" AND "); static ::rtl::OUString aQuote = m_xConnection->getMetaData()->getIdentifierQuoteString(); ::rtl::OUString aFilter; ::std::vector< ::rtl::OUString>::const_iterator aIter = m_aColumnNames.begin(); for(;aIter != m_aColumnNames.end();) { ((aFilter += aQuote) += *aIter) += aQuote; aFilter += ::rtl::OUString::createFromAscii(" = ?"); ++aIter; if(aIter != m_aColumnNames.end()) aFilter += aAnd; } _xComposer->setFilter(aFilter); m_xStatement = m_xConnection->prepareStatement(_xComposer->getComposedQuery()); } catch(SQLException&) { } } // ----------------------------------------------------------------------------- OKeySet::~OKeySet() { ::comphelper::disposeComponent(m_xStatement); } // ------------------------------------------------------------------------- Any SAL_CALL OKeySet::getBookmark( const ORowSetRow& _rRow ) throw(SQLException, RuntimeException) { OSL_ENSURE(m_aKeyIter != m_aKeyMap.end() && m_aKeyIter != m_aKeyMap.begin(), "getBookmark is only possible when we stand on a valid row!"); return makeAny(m_aKeyIter->first); } // ------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::moveToBookmark( const Any& bookmark ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; m_aKeyIter = m_aKeyMap.find(::comphelper::getINT32(bookmark)); return m_aKeyIter != m_aKeyMap.end(); } // ------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::moveRelativeToBookmark( const Any& bookmark, sal_Int32 rows ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; m_aKeyIter = m_aKeyMap.find(::comphelper::getINT32(bookmark)); if(m_aKeyIter != m_aKeyMap.end()) { relative(rows); } return !isBeforeFirst() && !isAfterLast(); } // ------------------------------------------------------------------------- sal_Int32 SAL_CALL OKeySet::compareBookmarks( const Any& first, const Any& second ) throw(SQLException, RuntimeException) { sal_Int32 nFirst,nSecond; first >>= nFirst; second >>= nSecond; return (nFirst != nSecond) ? CompareBookmark::NOT_EQUAL : CompareBookmark::EQUAL; } // ------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::hasOrderedBookmarks( ) throw(SQLException, RuntimeException) { return sal_True; } // ------------------------------------------------------------------------- sal_Int32 SAL_CALL OKeySet::hashBookmark( const Any& bookmark ) throw(SQLException, RuntimeException) { return ::comphelper::getINT32(bookmark); } // ------------------------------------------------------------------------- // ::com::sun::star::sdbcx::XDeleteRows Sequence< sal_Int32 > SAL_CALL OKeySet::deleteRows( const Sequence< Any >& rows ,const connectivity::OSQLTable& _xTable) throw(SQLException, RuntimeException) { Reference xSet(_xTable,UNO_QUERY); fillTableName(xSet); ::rtl::OUString aSql = ::rtl::OUString::createFromAscii("DELETE FROM "); aSql += m_aComposedTableName; aSql += ::rtl::OUString::createFromAscii(" WHERE "); // list all cloumns that should be set static ::rtl::OUString aQuote = m_xConnection->getMetaData()->getIdentifierQuoteString(); static ::rtl::OUString aAnd = ::rtl::OUString::createFromAscii(" AND "); static ::rtl::OUString aOr = ::rtl::OUString::createFromAscii(" OR "); // use keys and indexes for excat postioning // first the keys Reference xKeySup(_xTable,UNO_QUERY); Reference xKeys; if(xKeySup.is()) xKeys = xKeySup->getKeys(); Reference xKeyColsSup; Reference xKeyColumns; if(xKeys.is()) { Reference xProp; for(sal_Int32 i=0;i< xKeys->getCount();++i) { xKeys->getByIndex(i) >>= xProp; sal_Int32 nKeyType = 0; xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; if(KeyType::PRIMARY == nKeyType) { xKeyColsSup = Reference(xProp,UNO_QUERY); break; } } if(xKeyColsSup.is()) xKeyColumns = xKeyColsSup->getColumns(); } if(!xKeyColumns.is()) throw SQLException(); ::rtl::OUString aColumnName; const Any* pBegin = rows.getConstArray(); const Any* pEnd = pBegin + rows.getLength(); Sequence< ::rtl::OUString> aColumnNames = xKeyColumns->getElementNames(); Sequence< Any > aKeys; for(;pBegin != pEnd;++pBegin) { aSql += ::rtl::OUString::createFromAscii("( "); // pBegin >>= aKeys; const ::rtl::OUString*pColumnBegin = aColumnNames.getConstArray(); const ::rtl::OUString*pColumnEnd = pColumnBegin + aColumnNames.getLength(); for(;pColumnBegin != pColumnEnd;++pColumnBegin) { ((aSql += aQuote) += *pColumnBegin) += aQuote; aSql += ::rtl::OUString::createFromAscii(" = ?"); aSql += aAnd; } aSql = aSql.replaceAt(aSql.getLength()-5,5,::rtl::OUString::createFromAscii(" )")); aSql += aOr; } aSql = aSql.replaceAt(aSql.getLength()-3,3,::rtl::OUString::createFromAscii(" ")); // now create end execute the prepared statement Reference< XPreparedStatement > xPrep(m_xConnection->prepareStatement(aSql)); Reference< XParameters > xParameter(xPrep,UNO_QUERY); pBegin = rows.getConstArray(); sal_Int32 i=1; for(;pBegin != pEnd;++pBegin) { Sequence< Any >* pValuePair = (Sequence< Any >*)pBegin->getValue(); const Any* pValBegin = pValuePair->getConstArray(); const Any* pValEnd = pValBegin + pValuePair->getLength(); for(;pValBegin != pValEnd; ++pValBegin,++i) { switch(pValBegin->getValueTypeClass()) { case TypeClass_STRING: case TypeClass_CHAR: { ::rtl::OUString aVal; *pValBegin >>= aVal; xParameter->setString(i,aVal); } break; case TypeClass_BOOLEAN: xParameter->setBoolean(i,*(sal_Bool*)pValBegin->getValue()); break; case TypeClass_BYTE: xParameter->setByte(i,*(sal_Int8*)pValBegin->getValue()); break; case TypeClass_SHORT: case TypeClass_UNSIGNED_SHORT: xParameter->setShort(i,*(sal_Int16*)pValBegin->getValue()); break; case TypeClass_LONG: case TypeClass_UNSIGNED_LONG: xParameter->setInt(i,*(sal_Int32*)pValBegin->getValue()); break; case TypeClass_FLOAT: xParameter->setFloat(i,*(float*)pValBegin->getValue()); break; case TypeClass_DOUBLE: xParameter->setDouble(i,*(double*)pValBegin->getValue()); break; }; } } sal_Bool bOk = xPrep->executeUpdate() > 0; Sequence< sal_Int32 > aRet(rows.getLength()); memset(aRet.getArray(),bOk,sizeof(sal_Int32)*aRet.getLength()); if(bOk) { const Any* pBegin = rows.getConstArray(); const Any* pEnd = pBegin + rows.getLength(); for(;pBegin != pEnd;++pBegin) { sal_Int32 nPos; *pBegin >>= nPos; m_aKeyMap.erase(nPos); } } return aRet; } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::updateRow(const ORowSetRow& _rInsertRow ,const ORowSetRow& _rOrginalRow,const connectivity::OSQLTable& _xTable ) throw(SQLException, RuntimeException) { OCacheSet::updateRow( _rInsertRow,_rOrginalRow,_xTable); if(rowUpdated()) { m_aKeyIter = m_aKeyMap.find(::comphelper::getINT32((*_rInsertRow)[0].getAny())); connectivity::ORowVector< ORowSetValue >::iterator aIter = m_aKeyIter->second->begin(); ::std::vector< sal_Int32>::const_iterator aPosIter = m_aColumnPos.begin(); for(;aPosIter != m_aColumnPos.end();++aPosIter,++aIter) *aIter = (*_rInsertRow)[*aPosIter]; } } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::insertRow( const ORowSetRow& _rInsertRow,const connectivity::OSQLTable& _xTable ) throw(SQLException, RuntimeException) { OCacheSet::insertRow( _rInsertRow,_xTable); if(rowInserted()) { ORowSetRow aKeyRow = new connectivity::ORowVector< ORowSetValue >(m_aColumnPos.size()); connectivity::ORowVector< ORowSetValue >::iterator aIter = aKeyRow->begin(); ::std::vector< sal_Int32>::const_iterator aPosIter = m_aColumnPos.begin(); for(;aPosIter != m_aColumnPos.end();++aPosIter,++aIter) *aIter = (*_rInsertRow)[*aPosIter]; OKeySetMatrix::iterator aKeyIter = m_aKeyMap.end(); --aKeyIter; m_aKeyIter = m_aKeyMap.insert(OKeySetMatrix::value_type(aKeyIter->first + 1,aKeyRow)).first; // now we set the bookmark for this row (*_rInsertRow)[0] = makeAny((sal_Int32)m_aKeyIter->first); } } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::deleteRow(const ORowSetRow& _rDeleteRow,const connectivity::OSQLTable& _xTable ) throw(SQLException, RuntimeException) { OCacheSet::deleteRow(_rDeleteRow,_xTable); if(rowDeleted()) { sal_Int32 nPos = ::comphelper::getINT32((*_rDeleteRow)[0].getAny()); m_aKeyMap.erase(nPos); m_aKeyIter = m_aKeyMap.end(); } } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::cancelRowUpdates( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::moveToInsertRow( ) throw(SQLException, RuntimeException) { } // ------------------------------------------------------------------------- void SAL_CALL OKeySet::moveToCurrentRow( ) throw(SQLException, RuntimeException) { } // ------------------------------------------------------------------------- ::std::vector< ::rtl::OUString> OKeySet::getColumnNames() { // use keys and indexes for excat postioning // first the keys Reference xKeySup(m_xTable,UNO_QUERY); Reference xKeys; if(xKeySup.is()) xKeys = xKeySup->getKeys(); Reference xKeyColsSup; Reference xKeyColumns; ::std::vector< ::rtl::OUString> aColumnNames; if(xKeys.is()) { Reference xProp; for(sal_Int32 i=0;i< xKeys->getCount();++i) { xKeys->getByIndex(i) >>= xProp; sal_Int32 nKeyType = 0; xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; if(KeyType::PRIMARY == nKeyType) { xKeyColsSup = Reference(xProp,UNO_QUERY); OSL_ENSURE(xKeyColsSup.is(),"Columnsupplier is null!"); xKeyColumns = xKeyColsSup->getColumns(); if(xKeyColumns.is()) { Sequence< ::rtl::OUString> aSeqNames = xKeyColumns->getElementNames(); const ::rtl::OUString*pColumnBegin = aSeqNames.getConstArray(); const ::rtl::OUString*pColumnEnd = pColumnBegin + aSeqNames.getLength(); for(;pColumnBegin != pColumnEnd;++pColumnBegin) aColumnNames.push_back(*pColumnBegin); } break; } } } return aColumnNames; } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::next( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; if(isAfterLast()) return sal_False; if(!m_bRowCountFinal) // not yet all records fetched { ++m_aKeyIter; // this is possible because we stand on begin() and this is the "beforefirst" row if(m_aKeyIter == m_aKeyMap.end() && !fetchRow()) m_aKeyIter = m_aKeyMap.end(); } else if(!isAfterLast()) ++m_aKeyIter; refreshRow(); return !isAfterLast(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::isBeforeFirst( ) throw(SQLException, RuntimeException) { return m_aKeyIter == m_aKeyMap.begin(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::isAfterLast( ) throw(SQLException, RuntimeException) { return m_bRowCountFinal && m_aKeyIter == m_aKeyMap.end(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::isFirst( ) throw(SQLException, RuntimeException) { OKeySetMatrix::iterator aTemp = m_aKeyMap.begin(); ++aTemp; return m_aKeyIter == aTemp && m_aKeyIter != m_aKeyMap.end(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::isLast( ) throw(SQLException, RuntimeException) { if(!m_bRowCountFinal) return sal_False; OKeySetMatrix::iterator aTemp = m_aKeyMap.end(); --aTemp; return m_aKeyIter == aTemp; } // ----------------------------------------------------------------------------- void SAL_CALL OKeySet::beforeFirst( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; m_aKeyIter = m_aKeyMap.begin(); m_xSet = NULL; ::comphelper::disposeComponent(m_xRow); } // ----------------------------------------------------------------------------- void SAL_CALL OKeySet::afterLast( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; fillAllRows(); m_aKeyIter = m_aKeyMap.end(); m_xSet = NULL; ::comphelper::disposeComponent(m_xRow); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::first( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; m_aKeyIter = m_aKeyMap.begin(); ++m_aKeyIter; if(m_aKeyIter == m_aKeyMap.end() && !fetchRow()) m_aKeyIter = m_aKeyMap.end(); refreshRow(); return m_aKeyIter != m_aKeyMap.end() && m_aKeyIter != m_aKeyMap.begin(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::last( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; fillAllRows(); m_aKeyIter = m_aKeyMap.end(); --m_aKeyIter; refreshRow(); return m_aKeyIter != m_aKeyMap.end() && m_aKeyIter != m_aKeyMap.begin(); } // ----------------------------------------------------------------------------- sal_Int32 SAL_CALL OKeySet::getRow( ) throw(SQLException, RuntimeException) { OSL_ENSURE(!isAfterLast(),"getRow is not allowed when afterlast record!"); OSL_ENSURE(!isBeforeFirst(),"getRow is not allowed when beforefirst record!"); OKeySetMatrix::iterator aTemp = m_aKeyIter; sal_Int32 i=0; while(aTemp-- != m_aKeyMap.begin()) ++i; return i; } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; OSL_ENSURE(row,"absolute(0) isn't allowed!"); if(row < 0) { if(!m_bRowCountFinal) fillAllRows(); for(;row < 0 && m_aKeyIter != m_aKeyMap.begin();++row) m_aKeyIter--; } else { if(row >= m_aKeyMap.size()) { if(!m_bRowCountFinal) { sal_Bool bNext = sal_True; for(sal_Int32 i=m_aKeyMap.size()-1;i < row && bNext;++i) bNext = fetchRow(); } else m_aKeyIter = m_aKeyMap.end(); } else { m_aKeyIter = m_aKeyMap.begin(); for(;row > 0 && m_aKeyIter != m_aKeyMap.end();--row) ++m_aKeyIter; } } refreshRow(); return m_aKeyIter != m_aKeyMap.end() && m_aKeyIter != m_aKeyMap.begin(); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::relative( sal_Int32 rows ) throw(SQLException, RuntimeException) { if(!rows) { refreshRow(); return sal_True; } return absolute(getRow()+rows); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OKeySet::previous( ) throw(SQLException, RuntimeException) { m_bInserted = m_bUpdated = m_bDeleted = sal_False; if(m_aKeyIter != m_aKeyMap.begin()) { --m_aKeyIter; refreshRow(); } return m_aKeyIter != m_aKeyMap.begin(); } // ----------------------------------------------------------------------------- void SAL_CALL OKeySet::refreshRow() throw(SQLException, RuntimeException) { if(isBeforeFirst() || isAfterLast() || !m_xStatement.is()) return; m_xSet = NULL; ::comphelper::disposeComponent(m_xRow); // we just areassign the base members Reference< XParameters > xParameter(m_xStatement,UNO_QUERY); connectivity::ORowVector< ORowSetValue >::iterator aIter = m_aKeyIter->second->begin(); ::std::vector< ::rtl::OUString>::const_iterator aPosIter = m_aColumnNames.begin(); for(sal_Int32 nPos=1;aPosIter != m_aColumnNames.end();++aPosIter,++aIter,++nPos) { switch(aIter->getTypeKind()) { case DataType::CHAR: case DataType::VARCHAR: xParameter->setString(nPos,*aIter); break; case DataType::DOUBLE: case DataType::FLOAT: case DataType::REAL: case DataType::DECIMAL: case DataType::NUMERIC: xParameter->setDouble(nPos,*aIter); break; case DataType::DATE: xParameter->setDate(nPos,*aIter); break; case DataType::TIME: xParameter->setTime(nPos,*aIter); break; case DataType::TIMESTAMP: xParameter->setTimestamp(nPos,*aIter); break; case DataType::BINARY: case DataType::VARBINARY: case DataType::LONGVARBINARY: case DataType::LONGVARCHAR: xParameter->setBytes(nPos,*aIter); break; case DataType::BIT: xParameter->setBoolean(nPos,*aIter); break; case DataType::TINYINT: xParameter->setByte(nPos,*aIter); break; case DataType::SMALLINT: xParameter->setShort(nPos,*aIter); break; case DataType::INTEGER: xParameter->setInt(nPos,*aIter); break; } } m_xSet = m_xStatement->executeQuery(); OSL_ENSURE(m_xSet.is(),"No resultset form statement!"); sal_Bool bOK = m_xSet->next(); OSL_ENSURE(bOK,"No rows!"); m_xRow = Reference< XRow>(m_xSet,UNO_QUERY); OSL_ENSURE(m_xRow.is(),"No row form statement!"); } // ----------------------------------------------------------------------------- sal_Bool OKeySet::fetchRow() { sal_Bool bRet; if(!m_bRowCountFinal && (bRet = m_xDriverSet->next())) { ORowSetRow aKeyRow = new connectivity::ORowVector< ORowSetValue >(m_aColumnPos.size()); connectivity::ORowVector< ORowSetValue >::iterator aIter = aKeyRow->begin(); ::std::vector< sal_Int32>::const_iterator aPosIter = m_aColumnPos.begin(); for(;aPosIter != m_aColumnPos.end();++aPosIter,++aIter) { sal_Int32 nType = m_xSetMetaData->getColumnType(*aPosIter); switch(nType) { case DataType::CHAR: case DataType::VARCHAR: (*aIter) = m_xDriverRow->getString(*aPosIter); break; case DataType::DOUBLE: case DataType::FLOAT: case DataType::REAL: case DataType::DECIMAL: case DataType::NUMERIC: (*aIter) = m_xDriverRow->getDouble(*aPosIter); break; case DataType::DATE: (*aIter) = m_xDriverRow->getDate(*aPosIter); break; case DataType::TIME: (*aIter) = m_xDriverRow->getTime(*aPosIter); break; case DataType::TIMESTAMP: (*aIter) = m_xDriverRow->getTimestamp(*aPosIter); break; case DataType::BINARY: case DataType::VARBINARY: case DataType::LONGVARBINARY: case DataType::LONGVARCHAR: (*aIter) = m_xDriverRow->getBytes(*aPosIter); break; case DataType::BIT: (*aIter) = m_xDriverRow->getBoolean(*aPosIter); break; case DataType::TINYINT: (*aIter) = (sal_Int32)m_xDriverRow->getByte(*aPosIter); break; case DataType::SMALLINT: (*aIter) = (sal_Int32)m_xDriverRow->getShort(*aPosIter); break; case DataType::INTEGER: (*aIter) = m_xDriverRow->getInt(*aPosIter); break; } if(m_xDriverRow->wasNull()) aIter->setNull(); aIter->setTypeKind(nType); } m_aKeyIter = m_aKeyMap.insert(OKeySetMatrix::value_type(m_aKeyMap.size(),aKeyRow)).first; } else m_bRowCountFinal = sal_True; return bRet; } // ------------------------------------------------------------------------- void OKeySet::fillAllRows() { if(!m_bRowCountFinal) { while(fetchRow()) ; } } // ----------------------------------------------------------------------------- /*------------------------------------------------------------------------ $Log: not supported by cvs2svn $ Revision 1.8 2001/01/24 09:50:49 oj #82628# rowset modifications Revision 1.7 2001/01/22 07:38:23 oj #82632# change member Revision 1.6 2000/11/15 15:57:40 oj change for rowset Revision 1.5 2000/10/30 09:24:02 oj use tablecontainer if no tablesupplier is supported Revision 1.4 2000/10/25 07:30:24 oj make strings unique for lib's Revision 1.3 2000/10/17 10:18:12 oj some changes for the rowset Revision 1.2 2000/10/11 11:18:10 fs replace unotools with comphelper Revision 1.1.1.1 2000/09/19 00:15:38 hr initial import Revision 1.2 2000/09/18 14:52:46 willem.vandorp OpenOffice header added. Revision 1.1 2000/09/01 15:19:46 oj rowset addons Revision 1.0 01.08.2000 09:09:34 oj ------------------------------------------------------------------------*/