?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / dbaccess / source / core / api / RowSetCache.cxx
blob91ba4a0c7b429c565240a7f7ef3c001106710cf0
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: RowSetCache.cxx,v $
10 * $Revision: 1.100 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_dbaccess.hxx"
33
34 #ifndef _COMPHELPER_SEQSTREAM_HXX
35 #include <comphelper/seqstream.hxx>
36 #endif
37 #ifndef _COMPHELPER_UNO3_HXX_
38 #include <comphelper/uno3.hxx>
39 #endif
40 #ifndef _COMPHELPER_EXTRACT_HXX_
41 #include <comphelper/extract.hxx>
42 #endif
43 #ifndef _COM_SUN_STAR_SDBCX_XKEYSSUPPLIER_HPP_
44 #include <com/sun/star/sdbcx/XKeysSupplier.hpp>
45 #endif
46 #ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_
47 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
48 #endif
49 #ifndef _COM_SUN_STAR_SDBCX_KEYTYPE_HPP_
50 #include <com/sun/star/sdbcx/KeyType.hpp>
51 #endif
52 #ifndef _COM_SUN_STAR_SDBC_RESULTSETCONCURRENCY_HPP_
53 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
54 #endif
55 #ifndef _COM_SUN_STAR_SDBC_COLUMNVALUE_HPP_
56 #include <com/sun/star/sdbc/ColumnValue.hpp>
57 #endif
58 #ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_
59 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
60 #endif
61 #ifndef _COM_SUN_STAR_SDBCX_PRIVILEGE_HPP_
62 #include <com/sun/star/sdbcx/Privilege.hpp>
63 #endif
64 #ifndef _DBACORE_DATACOLUMN_HXX_
65 #include "CRowSetDataColumn.hxx"
66 #endif
67 #ifndef DBACCESS_CORE_API_CROWSETCOLUMN_HXX
68 #include "CRowSetColumn.hxx"
69 #endif
70 #ifndef DBACCESS_CORE_API_ROWSETBASE_HXX
71 #include "RowSetBase.hxx"
72 #endif
73 #ifndef _DBHELPER_DBEXCEPTION_HXX_
74 #include <connectivity/dbexception.hxx>
75 #endif
76 #ifndef _CONNECTIVITY_SQLPARSE_HXX
77 #include <connectivity/sqlparse.hxx>
78 #endif
79 #ifndef _CONNECTIVITY_SQLNODE_HXX
80 #include <connectivity/sqlnode.hxx>
81 #endif
82 #ifndef _CONNECTIVITY_PARSE_SQLITERATOR_HXX_
83 #include <connectivity/sqliterator.hxx>
84 #endif
85 #ifndef _COMPHELPER_PROPERTY_HXX_
86 #include <comphelper/property.hxx>
87 #endif
88 #ifndef _COM_SUN_STAR_SDBCX_COMPAREBOOKMARK_HPP_
89 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
90 #endif
91 #ifndef _TOOLS_DEBUG_HXX
92 #include <tools/debug.hxx>
93 #endif
94
95 #include <algorithm>
96 #ifndef DBACCESS_CORE_API_ROWSETCACHE_HXX
97 #include "RowSetCache.hxx"
98 #endif
99 #ifndef _DBA_CORE_RESOURCE_HXX_
100 #include "core_resource.hxx"
101 #endif
102 #ifndef _DBA_CORE_RESOURCE_HRC_
103 #include "core_resource.hrc"
104 #endif
105 #ifndef DBACCESS_CORE_API_BOOKMARKSET_HXX
106 #include "BookmarkSet.hxx"
107 #endif
108 #ifndef DBACCESS_CORE_API_STATICSET_HXX
109 #include "StaticSet.hxx"
110 #endif
111 #ifndef DBACCESS_CORE_API_KEYSET_HXX
112 #include "KeySet.hxx"
113 #endif
114 #ifndef DBACCESS_SHARED_DBASTRINGS_HRC
115 #include "dbastrings.hrc"
116 #endif
117
118 using namespace dbaccess;
119 using namespace dbtools;
120 using namespace connectivity;
121 using namespace ::com::sun::star::uno;
122 using namespace ::com::sun::star::beans;
123 using namespace ::com::sun::star::sdbc;
124 using namespace ::com::sun::star::sdb;
125 using namespace ::com::sun::star::sdbcx;
126 using namespace ::com::sun::star::container;
127 using namespace ::com::sun::star::lang;
128 using namespace ::cppu;
129 using namespace ::osl;
130
131 #define CHECK_MATRIX_POS(M) OSL_ENSURE(((M) >= static_cast<ORowSetMatrix::difference_type>(0)) && ((M) < static_cast<sal_Int32>(m_pMatrix->size())),"Position is invalid!")
132
133 DBG_NAME(ORowSetCache)
134 // -------------------------------------------------------------------------
135 ORowSetCache::ORowSetCache(const Reference< XResultSet >& _xRs,
136 const Reference< XSingleSelectQueryAnalyzer >& _xAnalyzer,
137 const ::comphelper::ComponentContext& _rContext,
138 const ::rtl::OUString& _rUpdateTableName,
139 sal_Bool& _bModified,
140 sal_Bool& _bNew,
141 const ORowSetValueVector& _aParameterValueForCache)
142 :m_xSet(_xRs)
143 ,m_xMetaData(Reference< XResultSetMetaDataSupplier >(_xRs,UNO_QUERY)->getMetaData())
144 ,m_aContext( _rContext )
145 ,m_pCacheSet(NULL)
146 ,m_pMatrix(NULL)
147 ,m_pInsertMatrix(NULL)
148 ,m_nLastColumnIndex(0)
149 ,m_nFetchSize(0)
150 ,m_nRowCount(0)
151 ,m_nPrivileges( Privilege::SELECT )
152 ,m_nPosition(0)
153 ,m_nStartPos(0)
154 ,m_nEndPos(0)
155 ,m_bRowCountFinal(sal_False)
156 ,m_bBeforeFirst(sal_True)
157 ,m_bAfterLast( sal_False )
158 ,m_bUpdated(sal_False)
159 ,m_bModified(_bModified)
160 ,m_bNew(_bNew)
161 {
162 DBG_CTOR(ORowSetCache,NULL);
163
164 // check if all keys of the updateable table are fetched
165 sal_Bool bAllKeysFound = sal_False;
166 sal_Int32 nTablesCount = 0;
167
168 Reference< XIndexAccess> xUpdateTableKeys;
169 ::rtl::OUString aUpdateTableName = _rUpdateTableName;
170 Reference< XConnection> xConnection;
171 if(_xAnalyzer.is())
172 {
173 try
174 {
175 Reference<XTablesSupplier> xTabSup(_xAnalyzer,UNO_QUERY);
176 OSL_ENSURE(xTabSup.is(),"ORowSet::execute composer isn't a tablesupplier!");
177 Reference<XNameAccess> xTables = xTabSup->getTables();
178
179
180 if(_rUpdateTableName.getLength() && xTables->hasByName(_rUpdateTableName))
181 xTables->getByName(_rUpdateTableName) >>= m_aUpdateTable;
182 else if(xTables->getElementNames().getLength())
183 {
184 aUpdateTableName = xTables->getElementNames()[0];
185 xTables->getByName(aUpdateTableName) >>= m_aUpdateTable;
186 }
187 Reference<XIndexAccess> xIndexAccess(xTables,UNO_QUERY);
188 if(xIndexAccess.is())
189 nTablesCount = xIndexAccess->getCount();
190 else
191 nTablesCount = xTables->getElementNames().getLength();
192
193 if(m_aUpdateTable.is() && nTablesCount < 3) // for we can't handle more than 2 tables in our keyset
194 {
195 Reference<XKeysSupplier> xKeys(m_aUpdateTable,UNO_QUERY);
196 if(xKeys.is())
197 {
198 xUpdateTableKeys = xKeys->getKeys();
199 if ( xUpdateTableKeys.is() )
200 {
201 Reference<XColumnsSupplier> xColumnsSupplier;
202 // search the one and only primary key
203 const sal_Int32 nCount = xUpdateTableKeys->getCount();
204 for(sal_Int32 i = 0 ; i < nCount ; ++i)
205 {
206 Reference<XPropertySet> xProp(xUpdateTableKeys->getByIndex(i),UNO_QUERY);
207 sal_Int32 nKeyType = 0;
208 xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType;
209 if(KeyType::PRIMARY == nKeyType)
210 {
211 xColumnsSupplier.set(xProp,UNO_QUERY);
212 break;
213 }
214 }
215
216 if(xColumnsSupplier.is())
217 {
218 // first we need a connection
219 Reference< XStatement> xStmt(_xRs->getStatement(),UNO_QUERY);
220 if(xStmt.is())
221 xConnection = xStmt->getConnection();
222 else
223 {
224 Reference< XPreparedStatement> xPrepStmt(_xRs->getStatement(),UNO_QUERY);
225 xConnection = xPrepStmt->getConnection();
226 }
227 OSL_ENSURE(xConnection.is(),"No connection!");
228
229 Reference<XNameAccess> xColumns = xColumnsSupplier->getColumns();
230 Reference<XColumnsSupplier> xColSup(_xAnalyzer,UNO_QUERY);
231 if ( xColSup.is() )
232 {
233 Reference<XNameAccess> xSelColumns = xColSup->getColumns();
234 Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
235 SelectColumnsMetaData aColumnNames(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers() ? true : false);
236 ::dbaccess::getColumnPositions(xSelColumns,xColumns,aUpdateTableName,aColumnNames);
237 bAllKeysFound = !aColumnNames.empty() && sal_Int32(aColumnNames.size()) == xColumns->getElementNames().getLength();
238 }
239 }
240 }
241 }
242 }
243 }
244 catch(Exception&)
245 {
246 }
247 }
248 Reference< XPropertySet> xProp(_xRs,UNO_QUERY);
249
250 sal_Bool bNeedKeySet = !(xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_ISBOOKMARKABLE) &&
251 any2bool(xProp->getPropertyValue(PROPERTY_ISBOOKMARKABLE)) && Reference< XRowLocate >(_xRs, UNO_QUERY).is() );
252 bNeedKeySet = bNeedKeySet || (xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_RESULTSETCONCURRENCY) &&
253 ::comphelper::getINT32(xProp->getPropertyValue(PROPERTY_RESULTSETCONCURRENCY)) == ResultSetConcurrency::READ_ONLY);
254
255 // first check if resultset is bookmarkable
256 if(!bNeedKeySet)
257 {
258 try
259 {
260 m_pCacheSet = new OBookmarkSet();
261 m_xCacheSet = m_pCacheSet;
262 m_pCacheSet->construct(_xRs);
263
264 // check privileges
265 m_nPrivileges = Privilege::SELECT;
266 if(Reference<XResultSetUpdate>(_xRs,UNO_QUERY).is()) // this interface is optional so we have to check it
267 {
268 Reference<XPropertySet> xTable(m_aUpdateTable,UNO_QUERY);
269 if(xTable.is() && xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_PRIVILEGES))
270 {
271 m_nPrivileges = 0;
272 xTable->getPropertyValue(PROPERTY_PRIVILEGES) >>= m_nPrivileges;
273 if(!m_nPrivileges)
274 m_nPrivileges = Privilege::SELECT;
275 }
276 }
277 }
278 catch(const SQLException&)
279 {
280 bNeedKeySet = sal_True;
281 }
282
283 }
284 if(bNeedKeySet)
285 {
286 // need to check if we could handle this select clause
287 bAllKeysFound = bAllKeysFound && (nTablesCount == 1 || checkJoin(xConnection,_xAnalyzer,aUpdateTableName));
288
289 // || !(comphelper::hasProperty(PROPERTY_CANUPDATEINSERTEDROWS,xProp) && any2bool(xProp->getPropertyValue(PROPERTY_CANUPDATEINSERTEDROWS)))
290
291 // oj removed because keyset uses only the next// || (xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_RESULTSETTYPE) && comphelper::getINT32(xProp->getPropertyValue(PROPERTY_RESULTSETTYPE)) == ResultSetType::FORWARD_ONLY)
292 if(!bAllKeysFound )
293 {
294 m_pCacheSet = new OStaticSet();
295 m_xCacheSet = m_pCacheSet;
296 m_pCacheSet->construct(_xRs);
297 m_nPrivileges = Privilege::SELECT;
298 }
299 else
300 {
301 Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
302 SelectColumnsMetaData aColumnNames(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers() ? true : false);
303 Reference<XColumnsSupplier> xColSup(_xAnalyzer,UNO_QUERY);
304 Reference<XNameAccess> xSelColumns = xColSup->getColumns();
305 Reference<XNameAccess> xColumns = m_aUpdateTable->getColumns();
306 ::dbaccess::getColumnPositions(xSelColumns,xColumns,aUpdateTableName,aColumnNames);
307
308 // check privileges
309 m_nPrivileges = Privilege::SELECT;
310 sal_Bool bNoInsert = sal_False;
311
312 Sequence< ::rtl::OUString> aNames(xColumns->getElementNames());
313 const ::rtl::OUString* pIter = aNames.getConstArray();
314 const ::rtl::OUString* pEnd = pIter + aNames.getLength();
315 for(;pIter != pEnd;++pIter)
316 {
317 Reference<XPropertySet> xColumn;
318 ::cppu::extractInterface(xColumn,xColumns->getByName(*pIter));
319 OSL_ENSURE(xColumn.is(),"Column in table is null!");
320 if(xColumn.is())
321 {
322 sal_Int32 nNullable = 0;
323 xColumn->getPropertyValue(PROPERTY_ISNULLABLE) >>= nNullable;
324 if(nNullable == ColumnValue::NO_NULLS && aColumnNames.find(*pIter) == aColumnNames.end())
325 { // we found a column where null is not allowed so we can't insert new values
326 bNoInsert = sal_True;
327 break; // one column is enough
328 }
329 }
330 }
331
332 OKeySet* pKeySet = new OKeySet(m_aUpdateTable,xUpdateTableKeys,aUpdateTableName ,_xAnalyzer,_aParameterValueForCache);
333 try
334 {
335 m_pCacheSet = pKeySet;
336 m_xCacheSet = m_pCacheSet;
337 pKeySet->construct(_xRs);
338
339 if(Reference<XResultSetUpdate>(_xRs,UNO_QUERY).is()) // this interface is optional so we have to check it
340 {
341 Reference<XPropertySet> xTable(m_aUpdateTable,UNO_QUERY);
342 if(xTable.is() && xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_PRIVILEGES))
343 {
344 m_nPrivileges = 0;
345 xTable->getPropertyValue(PROPERTY_PRIVILEGES) >>= m_nPrivileges;
346 if(!m_nPrivileges)
347 m_nPrivileges = Privilege::SELECT;
348 }
349 }
350 if(bNoInsert)
351 m_nPrivileges |= ~Privilege::INSERT; // remove the insert privilege
352 }
353 catch(const SQLException&)
354 {
355 // we couldn't create a keyset here so we have to create a static cache
356 if ( m_pCacheSet )
357 m_pCacheSet = NULL;
358 m_xCacheSet = NULL;
359 m_pCacheSet = new OStaticSet();
360 m_xCacheSet = m_pCacheSet;
361 m_pCacheSet->construct(_xRs);
362 m_nPrivileges = Privilege::SELECT;
363 }
364 }
365
366 }
367 // last check
368 if(!bAllKeysFound && xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_RESULTSETCONCURRENCY) &&
369 ::comphelper::getINT32(xProp->getPropertyValue(PROPERTY_RESULTSETCONCURRENCY)) == ResultSetConcurrency::READ_ONLY)
370 m_nPrivileges = Privilege::SELECT;
371 }
372
373 // -------------------------------------------------------------------------
374 ORowSetCache::~ORowSetCache()
375 {
376 m_pCacheSet = NULL;
377 m_xCacheSet = NULL;
378 if(m_pMatrix)
379 {
380 m_pMatrix->clear();
381 delete m_pMatrix;
382 }
383
384 if(m_pInsertMatrix)
385 {
386 m_pInsertMatrix->clear();
387 delete m_pInsertMatrix;
388 }
389 m_xSet = WeakReference< XResultSet>();
390 m_xMetaData = NULL;
391 m_aUpdateTable = NULL;
392
393 DBG_DTOR(ORowSetCache,NULL);
394 }
395
396 // -------------------------------------------------------------------------
397 void ORowSetCache::setMaxRowSize(sal_Int32 _nSize)
398 {
399
400 if(_nSize == m_nFetchSize)
401 return;
402
403 m_nFetchSize = _nSize;
404 if(!m_pMatrix)
405 {
406 m_pMatrix = new ORowSetMatrix(_nSize);
407 m_aMatrixIter = m_pMatrix->end();
408 m_aMatrixEnd = m_pMatrix->end();
409
410 m_pInsertMatrix = new ORowSetMatrix(1); // a little bit overkill but ??? :-)
411 m_aInsertRow = m_pInsertMatrix->end();
412 }
413 else
414 {
415 // now correct the iterator in our iterator vector
416 ::std::vector<sal_Int32> aPositions;
417 ::std::map<sal_Int32,sal_Bool> aCacheIterToChange;
418 // first get the positions where they stand now
419 ORowSetCacheMap::iterator aCacheIter = m_aCacheIterators.begin();
420 ORowSetCacheMap::iterator aCacheEnd = m_aCacheIterators.end();
421 for(;aCacheIter != aCacheEnd;++aCacheIter)
422 {
423 aCacheIterToChange[aCacheIter->first] = sal_False;
424 if ( !aCacheIter->second.pRowSet->isInsertRow()
425 /*&& aCacheIter->second.aIterator != m_pMatrix->end()*/ && !m_bModified )
426 {
427 ptrdiff_t nDist = (aCacheIter->second.aIterator - m_pMatrix->begin());
428 aPositions.push_back(nDist);
429 aCacheIterToChange[aCacheIter->first] = sal_True;
430 }
431 }
432 sal_Int32 nKeyPos = (m_aMatrixIter - m_pMatrix->begin());
433 m_pMatrix->resize(_nSize);
434
435 if ( nKeyPos < _nSize )
436 m_aMatrixIter = m_pMatrix->begin() + nKeyPos;
437 else
438 m_aMatrixIter = m_pMatrix->end();
439 m_aMatrixEnd = m_pMatrix->end();
440
441 // now adjust their positions because a resize invalid all iterators
442 ::std::vector<sal_Int32>::const_iterator aIter = aPositions.begin();
443 ::std::map<sal_Int32,sal_Bool>::const_iterator aPosChangeIter = aCacheIterToChange.begin();
444 for( aCacheIter = m_aCacheIterators.begin();
445 aPosChangeIter != aCacheIterToChange.end();
446 ++aPosChangeIter,++aCacheIter)
447 {
448 if ( aPosChangeIter->second )
449 {
450 CHECK_MATRIX_POS(*aIter);
451 if ( *aIter < _nSize )
452 aCacheIter->second.aIterator = m_pMatrix->begin() + *aIter++;
453 else
454 aCacheIter->second.aIterator = m_pMatrix->end();
455 }
456 }
457 }
458 if(!m_nPosition)
459 {
460 sal_Int32 nNewSt = 1;
461 fillMatrix(nNewSt,_nSize+1);
462 m_nStartPos = 0;
463 m_nEndPos = _nSize;
464 }
465 }
466 // -------------------------------------------------------------------------
467
468 // XResultSetMetaDataSupplier
469 Reference< XResultSetMetaData > ORowSetCache::getMetaData( )
470 {
471 return m_xMetaData;
472 }
473 // -------------------------------------------------------------------------
474 // ::com::sun::star::sdbcx::XRowLocate
475 Any ORowSetCache::getBookmark( )
476 {
477
478 if(m_bAfterLast)
479 throwFunctionSequenceException(m_xSet.get());
480
481 if ( m_aMatrixIter >= m_pMatrix->end() || m_aMatrixIter < m_pMatrix->begin() || !(*m_aMatrixIter).isValid())
482 {
483 return Any(); // this is allowed here because the rowset knowns what it is doing
484 }
485
486 switch(((*m_aMatrixIter)->get())[0].getTypeKind())
487 {
488 case DataType::TINYINT:
489 case DataType::SMALLINT:
490 case DataType::INTEGER:
491 return makeAny((sal_Int32)((*m_aMatrixIter)->get())[0]);
492 default:
493 if(((*m_aMatrixIter)->get())[0].isNull())
494 ((*m_aMatrixIter)->get())[0] = m_pCacheSet->getBookmark();
495 return ((*m_aMatrixIter)->get())[0].getAny();
496 }
497 }
498 // -------------------------------------------------------------------------
499 sal_Bool ORowSetCache::moveToBookmark( const Any& bookmark )
500 {
501 if ( m_pCacheSet->moveToBookmark(bookmark) )
502 {
503 m_bBeforeFirst = sal_False;
504 m_nPosition = m_pCacheSet->getRow();
505
506 checkPositionFlags();
507
508 if(!m_bAfterLast)
509 {
510 moveWindow();
511 checkPositionFlags();
512 if ( !m_bAfterLast )
513 {
514 m_aMatrixIter = calcPosition();
515 OSL_ENSURE(m_aMatrixIter->isValid(),"Iterator after moveToBookmark not valid");
516 }
517 else
518 m_aMatrixIter = m_pMatrix->end();
519 }
520 else
521 m_aMatrixIter = m_pMatrix->end();
522 }
523 else
524 return sal_False;
525
526 return m_aMatrixIter != m_pMatrix->end() && (*m_aMatrixIter).isValid();
527 }
528 // -------------------------------------------------------------------------
529 sal_Bool ORowSetCache::moveRelativeToBookmark( const Any& bookmark, sal_Int32 rows )
530 {
531 sal_Bool bRet( moveToBookmark( bookmark ) );
532 if ( bRet )
533 {
534 m_nPosition = m_pCacheSet->getRow() + rows;
535 absolute(m_nPosition);
536 // for(sal_Int32 i=0;i<rows && m_aMatrixIter != m_pMatrix->end();++i,++m_aMatrixIter) ;
537
538 bRet = m_aMatrixIter != m_pMatrix->end() && (*m_aMatrixIter).isValid();
539 }
540
541 return bRet;
542 }
543 // -------------------------------------------------------------------------
544 sal_Int32 ORowSetCache::compareBookmarks( const Any& _first, const Any& _second )
545 {
546 return (!_first.hasValue() || !_second.hasValue()) ? CompareBookmark::NOT_COMPARABLE : m_pCacheSet->compareBookmarks(_first,_second);
547 }
548 // -------------------------------------------------------------------------
549 sal_Bool ORowSetCache::hasOrderedBookmarks( )
550 {
551
552 return m_pCacheSet->hasOrderedBookmarks();
553 }
554 // -------------------------------------------------------------------------
555 sal_Int32 ORowSetCache::hashBookmark( const Any& bookmark )
556 {
557
558 return m_pCacheSet->hashBookmark(bookmark);
559 }
560 // -------------------------------------------------------------------------
561 // XRowUpdate
562 // -----------------------------------------------------------------------------
563 void ORowSetCache::updateValue(sal_Int32 columnIndex,const ORowSetValue& x)
564 {
565 checkUpdateConditions(columnIndex);
566
567
568 ((*m_aInsertRow)->get())[columnIndex].setBound(sal_True);
569 ((*m_aInsertRow)->get())[columnIndex] = x;
570 ((*m_aInsertRow)->get())[columnIndex].setModified();
571 }
572 // -------------------------------------------------------------------------
573 void ORowSetCache::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length )
574 {
575 checkUpdateConditions(columnIndex);
576
577
578 Sequence<sal_Int8> aSeq;
579 if(x.is())
580 x->readBytes(aSeq,length);
581 updateValue(columnIndex,aSeq);
582 }
583 // -------------------------------------------------------------------------
584 void ORowSetCache::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length )
585 {
586 checkUpdateConditions(columnIndex);
587
588
589 Sequence<sal_Int8> aSeq;
590 if(x.is())
591 x->readBytes(aSeq,length);
592
593 updateValue(columnIndex,aSeq);
594 }
595 // -------------------------------------------------------------------------
596 void ORowSetCache::updateObject( sal_Int32 columnIndex, const Any& x )
597 {
598 checkUpdateConditions(columnIndex);
599
600
601 ((*m_aInsertRow)->get())[columnIndex].setBound(sal_True);
602 ((*m_aInsertRow)->get())[columnIndex] = x;
603 ((*m_aInsertRow)->get())[columnIndex].setModified();
604 }
605 // -------------------------------------------------------------------------
606 void ORowSetCache::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ )
607 {
608 checkUpdateConditions(columnIndex);
609
610
611 ((*m_aInsertRow)->get())[columnIndex].setBound(sal_True);
612 ((*m_aInsertRow)->get())[columnIndex] = x;
613 ((*m_aInsertRow)->get())[columnIndex].setModified();
614 }
615 // -------------------------------------------------------------------------
616 // XResultSet
617 sal_Bool ORowSetCache::next( )
618 {
619
620
621 if(!isAfterLast())
622 {
623 m_bBeforeFirst = sal_False;
624 ++m_nPosition;
625
626 // after we increment the position we have to check if we are already after the last row
627 checkPositionFlags();
628 if(!m_bAfterLast)
629 {
630 moveWindow();
631
632 OSL_ENSURE(((m_nPosition - m_nStartPos) - 1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
633 m_aMatrixIter = calcPosition();
634 checkPositionFlags();
635 }
636 }
637
638 return !m_bAfterLast;
639 }
640 // -------------------------------------------------------------------------
641 sal_Bool ORowSetCache::isBeforeFirst( )
642 {
643 // return !m_nPosition;
644
645 return m_bBeforeFirst;
646 }
647 // -------------------------------------------------------------------------
648 sal_Bool ORowSetCache::isAfterLast( )
649 {
650
651 return m_bAfterLast;
652 }
653 // -------------------------------------------------------------------------
654 sal_Bool ORowSetCache::isFirst( )
655 {
656
657 return m_nPosition == 1; // ask resultset for
658 }
659 // -------------------------------------------------------------------------
660 sal_Bool ORowSetCache::isLast( )
661 {
662 // return m_bRowCountFinal ? (m_nPosition==m_nRowCount) : m_pCacheSet->isLast();
663
664 return m_nPosition == m_nRowCount;
665 }
666 // -------------------------------------------------------------------------
667 sal_Bool ORowSetCache::beforeFirst( )
668 {
669
670
671 if(!m_bBeforeFirst)
672 {
673 m_bAfterLast = sal_False;
674 m_nPosition = 0;
675 m_bBeforeFirst = sal_True;
676 m_pCacheSet->beforeFirst();
677 moveWindow();
678 m_aMatrixIter = m_pMatrix->end();
679 }
680 return sal_True;
681 }
682 // -------------------------------------------------------------------------
683 sal_Bool ORowSetCache::afterLast( )
684 {
685
686
687 if(!m_bAfterLast)
688 {
689 m_bBeforeFirst = sal_False;
690 m_bAfterLast = sal_True;
691
692 if(!m_bRowCountFinal)
693 {
694 m_pCacheSet->last();
695 m_bRowCountFinal = sal_True;
696 m_nRowCount = m_pCacheSet->getRow();// + 1 removed
697 }
698 m_pCacheSet->afterLast();
699
700 m_nPosition = 0;
701 m_aMatrixIter = m_pMatrix->end();
702 }
703 return sal_True;
704 }
705 // -------------------------------------------------------------------------
706 sal_Bool ORowSetCache::fillMatrix(sal_Int32& _nNewStartPos,sal_Int32 _nNewEndPos)
707 {
708 OSL_ENSURE(_nNewStartPos != _nNewEndPos,"ORowSetCache::fillMatrix: StartPos and EndPos can not be equal!");
709 // fill the whole window with new data
710 ORowSetMatrix::iterator aIter = m_pMatrix->begin();
711 sal_Bool bCheck = m_pCacheSet->absolute(_nNewStartPos); // -1 no need to
712
713 sal_Int32 i=_nNewStartPos;
714 for(;i<_nNewEndPos;++i,++aIter)
715 {
716 if(bCheck)
717 {
718 if(!aIter->isValid())
719 *aIter = new ORowSetValueVector(m_xMetaData->getColumnCount());
720 m_pCacheSet->fillValueRow(*aIter,i);
721 }
722 else
723 { // there are no more rows found so we can fetch some before start
724
725 if(!m_bRowCountFinal)
726 {
727 if(m_pCacheSet->previous()) // because we stand after the last row
728 m_nRowCount = m_pCacheSet->getRow(); // here we have the row count
729 if(!m_nRowCount)
730 m_nRowCount = i-1; // it can be that getRow return zero
731 m_bRowCountFinal = sal_True;
732 }
733 if(m_nRowCount > m_nFetchSize)
734 {
735 ORowSetMatrix::iterator aEnd = aIter;
736 ORowSetMatrix::iterator aRealEnd = m_pMatrix->end();
737 sal_Int32 nPos = m_nRowCount - m_nFetchSize + 1;
738 _nNewStartPos = nPos;
739 bCheck = m_pCacheSet->absolute(_nNewStartPos);
740
741 for(;bCheck && aIter != aRealEnd;++aIter)
742 {
743 if(bCheck)
744 {
745 if(!aIter->isValid())
746 *aIter = new ORowSetValueVector(m_xMetaData->getColumnCount());
747 m_pCacheSet->fillValueRow(*aIter,nPos++);
748 }
749 bCheck = m_pCacheSet->next();
750 }
751 if(aIter != aEnd)
752 ::std::rotate(m_pMatrix->begin(),aEnd,aRealEnd);
753 }
754 break;
755 }
756 bCheck = m_pCacheSet->next();
757 }
758 // m_nStartPos = _nNewStartPos;
759 // we have to read one row forward to enshure that we know when we are on last row
760 // but only when we don't know it already
761 if(!m_bRowCountFinal)
762 {
763 if(!m_pCacheSet->next())
764 {
765 if(m_pCacheSet->previous()) // because we stand after the last row
766 m_nRowCount = m_pCacheSet->getRow(); // here we have the row count
767 m_bRowCountFinal = sal_True;
768 }
769 else
770 m_nRowCount = std::max(i,m_nRowCount);
771
772 }
773 return bCheck;
774 }
775 // -------------------------------------------------------------------------
776 sal_Bool ORowSetCache::moveWindow()
777 {
778
779 sal_Bool bRet = sal_True;
780
781 sal_Int32 nDiff = (sal_Int32)(m_nFetchSize*0.5 -0.5);
782 sal_Int32 nNewStartPos = (m_nPosition - nDiff);
783 // sal_Int32 nNewEndPos = (m_nPosition+m_nFetchSize*0.5);
784 sal_Int32 nNewEndPos = nNewStartPos + m_nFetchSize;
785
786 if ( m_nPosition <= m_nStartPos )
787 { // the window is behind the new start pos
788 if(!m_nStartPos)
789 return sal_False;
790 // the new position should be the nPos - nFetchSize/2
791 if ( nNewEndPos > m_nStartPos )
792 { // but the two regions are overlapping
793 // fill the rows behind the new end
794
795 ORowSetMatrix::iterator aEnd; // the iterator we need for rotate
796 ORowSetMatrix::iterator aIter; // the iterator we fill with new values
797
798 sal_Bool bCheck = sal_True;
799 if ( nNewStartPos < 1 )
800 {
801 bCheck = m_pCacheSet->first();
802 // aEnd = m_pMatrix->begin() + (sal_Int32)(m_nFetchSize*0.5);
803 OSL_ENSURE((nNewEndPos - m_nStartPos - nNewStartPos) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
804 aEnd = m_pMatrix->begin() + (nNewEndPos - m_nStartPos - nNewStartPos);
805 aIter = aEnd;
806 m_nStartPos = 0;
807 }
808 else
809 {
810 OSL_ENSURE((nNewEndPos - m_nStartPos -1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
811 aEnd = m_pMatrix->begin() + ((nNewEndPos - m_nStartPos)-1);
812 aIter = m_pMatrix->begin() + ((nNewEndPos - m_nStartPos)-1);
813 bCheck = m_pCacheSet->absolute(nNewStartPos);
814 m_nStartPos = nNewStartPos -1;
815 }
816
817 if ( bCheck )
818 {
819 sal_Int32 nPos = m_nStartPos;
820 bCheck = fill(aIter,m_pMatrix->end(),nPos,bCheck);
821
822 ::std::rotate(m_pMatrix->begin(),aEnd,m_pMatrix->end());
823 // now correct the iterator in our iterator vector
824 // rotateCacheIterator(aEnd-m_pMatrix->begin()); //can't be used because they decrement and here we need to increment
825 ptrdiff_t nNewDist = aEnd - m_pMatrix->begin();
826 ptrdiff_t nOffSet = m_pMatrix->end() - aEnd;
827 ORowSetCacheMap::iterator aCacheIter = m_aCacheIterators.begin();
828 ORowSetCacheMap::iterator aCacheEnd = m_aCacheIterators.end();
829 for(;aCacheIter != aCacheEnd;++aCacheIter)
830 {
831 if ( !aCacheIter->second.pRowSet->isInsertRow()
832 && aCacheIter->second.aIterator != m_pMatrix->end() && !m_bModified )
833 {
834 ptrdiff_t nDist = (aCacheIter->second.aIterator - m_pMatrix->begin());
835 if ( nDist >= nNewDist )
836 {
837 aCacheIter->second.aIterator = m_pMatrix->end();
838 }
839 else
840 {
841 #if OSL_DEBUG_LEVEL > 0
842 ORowSetMatrix::iterator aOldPos;
843 aOldPos = aCacheIter->second.aIterator;
844 #endif
845 CHECK_MATRIX_POS( ((aOldPos - m_pMatrix->begin()) + nOffSet) );
846 aCacheIter->second.aIterator += nOffSet;
847 #if OSL_DEBUG_LEVEL > 0
848 ORowSetMatrix::iterator aCurrentPos;
849 aCurrentPos = aCacheIter->second.aIterator;
850 #endif
851 OSL_ENSURE(aCacheIter->second.aIterator >= m_pMatrix->begin()
852 && aCacheIter->second.aIterator < m_pMatrix->end(),"Iterator out of area!");
853 }
854 }
855 }
856 }
857 else
858 { // normaly this should never happen
859 OSL_ENSURE(0,"What the hell is happen here!");
860 return sal_False;
861 }
862 }
863 else
864 {// no rows can be reused so fill again
865 if(nNewStartPos < 1) // special case
866 {
867 m_nStartPos = 0;
868
869 rotateCacheIterator(static_cast<sal_Int16>(m_nFetchSize+1)); // static_cast<sal_Int16>(m_nFetchSize+1)
870
871 m_pCacheSet->beforeFirst();
872
873 sal_Bool bCheck;
874 ORowSetMatrix::iterator aIter = m_pMatrix->begin();
875 for(sal_Int32 i=0;i<m_nFetchSize;++i,++aIter)
876 {
877 bCheck = m_pCacheSet->next();
878 if ( bCheck )
879 {
880 if(!aIter->isValid())
881 *aIter = new ORowSetValueVector(m_xMetaData->getColumnCount());
882 m_pCacheSet->fillValueRow(*aIter,i+1);
883 }
884 else
885 *aIter = NULL;
886 }
887 }
888 else
889 bRet = reFillMatrix(nNewStartPos,nNewEndPos);
890 }
891 }
892 else if(m_nPosition > m_nStartPos)
893 { // the new start pos is above the startpos of the window
894
895 if(m_nPosition <= (m_nStartPos+m_nFetchSize))
896 { // position in window
897 OSL_ENSURE((m_nPosition - m_nStartPos -1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
898 m_aMatrixIter = calcPosition();
899 if(!m_aMatrixIter->isValid())
900 {
901 sal_Bool bOk( m_pCacheSet->absolute( m_nPosition ) );
902 if ( bOk )
903 {
904 *m_aMatrixIter = new ORowSetValueVector(m_xMetaData->getColumnCount());
905 m_pCacheSet->fillValueRow(*m_aMatrixIter,m_nPosition);
906 // we have to read one row forward to enshure that we know when we are on last row
907 // but only when we don't know it already
908 if ( !m_bRowCountFinal )
909 {
910 bOk = m_pCacheSet->absolute( m_nPosition + 1 );
911 if ( bOk )
912 m_nRowCount = std::max(sal_Int32(m_nPosition+1),m_nRowCount);
913 }
914 }
915 if(!bOk)
916 {
917 if(!m_bRowCountFinal)
918 {
919 // because we stand after the last row
920 m_nRowCount = m_pCacheSet->previous() ? m_pCacheSet->getRow() : 0;// + 1 removed
921 m_bRowCountFinal = sal_True;
922 }
923 }
924 }
925 }
926 else if(nNewStartPos < (m_nStartPos+m_nFetchSize))
927 { // position behind window but the region is overlapping
928 // the rows from begin() to (begin + nNewStartPos - m_nStartPos) can be refilled with the new rows
929 // the rows behind this can be reused
930 ORowSetMatrix::iterator aIter = m_pMatrix->begin();
931 CHECK_MATRIX_POS(nNewStartPos - m_nStartPos - 1);
932 ORowSetMatrix::iterator aEnd = m_pMatrix->begin() + (nNewStartPos - m_nStartPos - 1);
933
934 sal_Int32 nPos = m_nStartPos + m_nFetchSize + 1;
935 sal_Bool bCheck = m_pCacheSet->absolute(nPos);
936 bCheck = fill(aIter,aEnd,nPos,bCheck); // refill the region wew don't need anymore
937
938 // // we know that this is the current maximal rowcount here
939 // if ( !m_bRowCountFinal && bCheck )
940 // m_nRowCount = std::max(nPos,m_nRowCount);
941 // we have to read one row forward to enshure that we know when we are on last row
942 // but only when we don't know it already
943 sal_Bool bOk = sal_True;
944 if(bCheck && !m_bRowCountFinal)
945 bOk = m_pCacheSet->next();
946 // bind end to front
947 if(bCheck)
948 { // rotate the end to the front
949 ::std::rotate(m_pMatrix->begin(),aIter,m_pMatrix->end());
950 // now correct the iterator in our iterator vector
951 rotateCacheIterator( (sal_Int16)( aIter - m_pMatrix->begin() ) );
952 m_nStartPos = nNewStartPos - 1; // must be -1
953 // now I can say how many rows we have
954 if(!bOk)
955 {
956 m_pCacheSet->previous(); // because we stand after the last row
957 m_nRowCount = nPos; // here we have the row count
958 m_bRowCountFinal = sal_True;
959 }
960 else if(!m_bRowCountFinal)
961 m_nRowCount = std::max(++nPos,m_nRowCount);
962 }
963 else
964 { // the end was reached before end() so we can set the start before nNewStartPos
965
966 m_nStartPos += (aIter - m_pMatrix->begin());
967 // m_nStartPos = (aIter - m_pMatrix->begin());
968 ::std::rotate(m_pMatrix->begin(),aIter,m_pMatrix->end());
969 // now correct the iterator in our iterator vector
970 rotateCacheIterator( (sal_Int16)( aIter - m_pMatrix->begin() ) );
971
972 if ( !m_bRowCountFinal )
973 {
974 m_pCacheSet->previous(); // because we stand after the last row
975 m_nRowCount = std::max(m_nRowCount,--nPos); // here we have the row count
976 OSL_ENSURE(nPos == m_pCacheSet->getRow(),"nPos isn't valid!");
977 m_bRowCountFinal = sal_True;
978 }
979 // TODO check
980 // m_nStartPos = (nNewStartPos+m_nRowCount) - m_nFetchSize ;
981 if(m_nStartPos < 0)
982 m_nStartPos = 0;
983 }
984 // here we need only to check if the begining row is valid. If not we have to fetch it.
985 if(!m_pMatrix->begin()->isValid())
986 {
987 aIter = m_pMatrix->begin();
988
989 nPos = m_nStartPos;
990 bCheck = m_pCacheSet->absolute(m_nStartPos);
991 for(; !aIter->isValid() && bCheck;++aIter)
992 {
993 OSL_ENSURE(aIter != m_pMatrix->end(),"Invalid iterator");
994 bCheck = m_pCacheSet->next();
995 if ( bCheck ) // resultset stands on right position
996 {
997 *aIter = new ORowSetValueVector(m_xMetaData->getColumnCount());
998 m_pCacheSet->fillValueRow(*aIter,++nPos);
999 }
1000 }
1001 }
1002 }
1003 else // no rows can be reused so fill again
1004 bRet = reFillMatrix(nNewStartPos,nNewEndPos);
1005 }
1006
1007 if(!m_bRowCountFinal)
1008 m_nRowCount = std::max(m_nPosition,m_nRowCount);
1009 OSL_ENSURE(m_nStartPos >= 0,"ORowSetCache::moveWindow: m_nStartPos is less than 0!");
1010
1011 return bRet;
1012 }
1013 // -------------------------------------------------------------------------
1014 sal_Bool ORowSetCache::first( )
1015 {
1016 // first move to the first row
1017 // then check if the cache window is at the begining
1018 // when not postionize the window and fill it with data
1019 // smart moving of the window -> clear only the rows whom are out of range
1020 sal_Bool bRet = m_pCacheSet->first();
1021 if(bRet)
1022 {
1023 m_bBeforeFirst = m_bAfterLast = sal_False;
1024 m_nPosition = 1;
1025 moveWindow();
1026 m_aMatrixIter = m_pMatrix->begin();
1027 }
1028 else
1029 {
1030 m_bRowCountFinal = m_bBeforeFirst = m_bAfterLast = sal_True;
1031 m_nRowCount = m_nPosition = 0;
1032
1033 OSL_ENSURE(m_bBeforeFirst || m_bNew,"ORowSetCache::first return false and BeforeFirst isn't true");
1034 m_aMatrixIter = m_pMatrix->end();
1035 }
1036 return bRet;
1037 }
1038 // -------------------------------------------------------------------------
1039 sal_Bool ORowSetCache::last( )
1040 {
1041 sal_Bool bRet = m_pCacheSet->last();
1042 if(bRet)
1043 {
1044 m_bBeforeFirst = m_bAfterLast = sal_False;
1045 if(!m_bRowCountFinal)
1046 {
1047 m_bRowCountFinal = sal_True;
1048 m_nRowCount = m_nPosition = m_pCacheSet->getRow(); // not + 1
1049 }
1050 m_nPosition = m_pCacheSet->getRow();
1051 moveWindow();
1052 // we have to repositioning because moveWindow can modify the cache
1053 m_pCacheSet->last();
1054 // if(m_nPosition > m_nFetchSize)
1055 // m_aMatrixIter = m_pMatrix->end() -1;
1056 // else
1057 // m_aMatrixIter = m_pMatrix->begin() + m_nPosition - 1;
1058 OSL_ENSURE(((m_nPosition - m_nStartPos) - 1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
1059 m_aMatrixIter = calcPosition();
1060 }
1061 else
1062 {
1063 m_bRowCountFinal = m_bBeforeFirst = m_bAfterLast = sal_True;
1064 m_nRowCount = m_nPosition = 0;
1065 OSL_ENSURE(m_bBeforeFirst,"ORowSetCache::last return false and BeforeFirst isn't true");
1066 m_aMatrixIter = m_pMatrix->end();
1067 }
1068 #if OSL_DEBUG_LEVEL > 1
1069 if(bRet)
1070 {
1071 OSL_ENSURE((*m_aMatrixIter).isValid(),"ORowSetCache::last: Row not valid!");
1072 }
1073 #endif
1074
1075 return bRet;
1076 }
1077 // -------------------------------------------------------------------------
1078 sal_Int32 ORowSetCache::getRow( )
1079 {
1080 return (isBeforeFirst() || isAfterLast()) ? 0 : m_nPosition;
1081 }
1082 // -------------------------------------------------------------------------
1083 sal_Bool ORowSetCache::absolute( sal_Int32 row )
1084 {
1085 if(!row )
1086 throw SQLException(DBACORE_RESSTRING(RID_STR_NO_ABS_ZERO),NULL,SQLSTATE_GENERAL,1000,Any() );
1087
1088 if(row < 0)
1089 {
1090 // here we have to scroll from the last row to backward so we have to go to last row and
1091 // and two the previous
1092 if(m_bRowCountFinal || last())
1093 {
1094 m_nPosition = m_nRowCount + row + 1; // + row because row is negative and +1 because row==-1 means last row
1095 if(m_nPosition < 1)
1096 {
1097 m_bBeforeFirst = sal_True;
1098 m_bAfterLast = sal_False;
1099 m_aMatrixIter = m_pMatrix->end();
1100 }
1101 else
1102 {
1103 m_bBeforeFirst = sal_False;
1104 m_bAfterLast = m_nPosition > m_nRowCount;
1105 moveWindow();
1106 OSL_ENSURE(((m_nPosition - m_nStartPos) - 1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
1107 m_aMatrixIter = calcPosition();
1108 }
1109 }
1110 else
1111 m_aMatrixIter = m_pMatrix->end();
1112 }
1113 else
1114 {
1115 m_nPosition = row;
1116 // the position flags
1117 m_bBeforeFirst = sal_False;
1118 checkPositionFlags();
1119
1120 if(!m_bAfterLast)
1121 {
1122 moveWindow();
1123 checkPositionFlags();
1124 if(!m_bAfterLast)
1125 m_aMatrixIter = calcPosition();
1126 else
1127 m_aMatrixIter = m_pMatrix->end();
1128 }
1129 else
1130 m_aMatrixIter = m_pMatrix->end();
1131 }
1132
1133 return !(m_bAfterLast || m_bBeforeFirst);
1134 }
1135 // -------------------------------------------------------------------------
1136 sal_Bool ORowSetCache::relative( sal_Int32 rows )
1137 {
1138 sal_Bool bErg = sal_True;
1139 if(rows)
1140 {
1141 sal_Int32 nNewPosition = m_nPosition + rows;
1142
1143 if ( m_bBeforeFirst && rows > 0 )
1144 nNewPosition = rows;
1145 else if ( m_bRowCountFinal && m_bAfterLast && rows < 0 )
1146 nNewPosition = m_nRowCount + 1 + rows;
1147 else
1148 if ( m_bBeforeFirst || ( m_bRowCountFinal && m_bAfterLast ) )
1149 throw SQLException( DBACORE_RESSTRING( RID_STR_NO_RELATIVE ), NULL, SQLSTATE_GENERAL, 1000, Any() );
1150 if ( nNewPosition )
1151 {
1152 bErg = absolute( nNewPosition );
1153 bErg = bErg && !isAfterLast() && !isBeforeFirst();
1154 }
1155 else
1156 {
1157 m_bBeforeFirst = sal_True;
1158 bErg = sal_False;
1159 }
1160 }
1161 return bErg;
1162 }
1163 // -------------------------------------------------------------------------
1164 sal_Bool ORowSetCache::previous( )
1165 {
1166 sal_Bool bRet = sal_False;
1167 if(!isBeforeFirst())
1168 {
1169 if(m_bAfterLast) // we stand after the last row so one before is the last row
1170 bRet = last();
1171 else
1172 {
1173 m_bAfterLast = sal_False;
1174 --m_nPosition;
1175 moveWindow();
1176 OSL_ENSURE(((m_nPosition - m_nStartPos) - 1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
1177
1178 checkPositionFlags();
1179
1180 if(!m_nPosition)
1181 {
1182 m_bBeforeFirst = sal_True;
1183 m_aMatrixIter = m_pMatrix->end();
1184 }
1185 else
1186 {
1187 m_aMatrixIter = calcPosition();
1188 bRet = (*m_aMatrixIter).isValid();
1189 }
1190 }
1191 }
1192 return bRet;
1193 }
1194 // -------------------------------------------------------------------------
1195 void ORowSetCache::refreshRow( )
1196 {
1197 if(isAfterLast())
1198 throw SQLException(DBACORE_RESSTRING(RID_STR_NO_REFESH_AFTERLAST),NULL,SQLSTATE_GENERAL,1000,Any() );
1199 OSL_ENSURE(m_aMatrixIter != m_pMatrix->end(),"refreshRow() called for invalid row!");
1200 m_pCacheSet->refreshRow();
1201 m_pCacheSet->fillValueRow(*m_aMatrixIter,m_nPosition);
1202 if ( m_bNew )
1203 {
1204 cancelRowModification();
1205 }
1206 }
1207 // -------------------------------------------------------------------------
1208 sal_Bool ORowSetCache::rowUpdated( )
1209 {
1210 return m_pCacheSet->rowUpdated();
1211 }
1212 // -------------------------------------------------------------------------
1213 sal_Bool ORowSetCache::rowInserted( )
1214 {
1215 return m_pCacheSet->rowInserted();
1216 }
1217 // -------------------------------------------------------------------------
1218 // XResultSetUpdate
1219 sal_Bool ORowSetCache::insertRow( )
1220 {
1221 if ( !m_bNew || !m_aInsertRow->isValid() )
1222 throw SQLException(DBACORE_RESSTRING(RID_STR_NO_MOVETOINSERTROW_CALLED),NULL,SQLSTATE_GENERAL,1000,Any() );
1223
1224 m_pCacheSet->insertRow(*m_aInsertRow,m_aUpdateTable);
1225
1226 sal_Bool bRet( rowInserted() );
1227 if ( bRet )
1228 {
1229 ++m_nRowCount;
1230 Any aBookmark = ((*m_aInsertRow)->get())[0].makeAny();
1231 m_bAfterLast = m_bBeforeFirst = sal_False;
1232 if(aBookmark.hasValue())
1233 moveToBookmark(aBookmark);
1234 else
1235 {
1236 OSL_ENSURE(0,"There must be a bookmark after the row was inserted!");
1237 }
1238 }
1239 return bRet;
1240 }
1241 // -------------------------------------------------------------------------
1242 void ORowSetCache::resetInsertRow(sal_Bool _bClearInsertRow)
1243 {
1244 if ( _bClearInsertRow )
1245 clearInsertRow();
1246 m_bNew = sal_False;
1247 m_bModified = sal_False;
1248 }
1249 // -------------------------------------------------------------------------
1250 void ORowSetCache::cancelRowModification()
1251 {
1252 // clear the insertrow references -> implies that the current row of the rowset changes as well
1253 ORowSetCacheMap::iterator aCacheIter = m_aCacheIterators.begin();
1254 ORowSetCacheMap::iterator aCacheEnd = m_aCacheIterators.end();
1255 for(;aCacheIter != aCacheEnd;++aCacheIter)
1256 {
1257 if ( aCacheIter->second.pRowSet->isInsertRow() && aCacheIter->second.aIterator == m_aInsertRow )
1258 aCacheIter->second.aIterator = m_pMatrix->end();
1259 } // for(;aCacheIter != aCacheEnd;++aCacheIter)
1260 resetInsertRow(sal_False);
1261 }
1262 // -------------------------------------------------------------------------
1263 void ORowSetCache::updateRow( ORowSetMatrix::iterator& _rUpdateRow )
1264 {
1265 if(isAfterLast() || isBeforeFirst())
1266 throw SQLException(DBACORE_RESSTRING(RID_STR_NO_UPDATEROW),NULL,SQLSTATE_GENERAL,1000,Any() );
1267
1268 Any aBookmark = ((*_rUpdateRow)->get())[0].makeAny();
1269 OSL_ENSURE(aBookmark.hasValue(),"Bookmark must have a value!");
1270 // here we don't have to reposition our CacheSet, when we try to update a row,
1271 // the row was already fetched
1272 moveToBookmark(aBookmark);
1273 m_pCacheSet->updateRow(*_rUpdateRow,*m_aMatrixIter,m_aUpdateTable);
1274 // *(*m_aMatrixIter) = *(*_rUpdateRow);
1275 // refetch the whole row
1276 (*m_aMatrixIter) = NULL;
1277 moveToBookmark(aBookmark);
1278
1279 // moveToBookmark((*(*m_aInsertRow))[0].makeAny());
1280 // if(m_pCacheSet->rowUpdated())
1281 // *m_aMatrixIter = m_aInsertRow;
1282 m_bModified = sal_False;
1283 // refreshRow( );
1284 }
1285 // -------------------------------------------------------------------------
1286 bool ORowSetCache::deleteRow( )
1287 {
1288 if(isAfterLast() || isBeforeFirst())
1289 throw SQLException(DBACORE_RESSTRING(RID_STR_NO_DELETEROW),NULL,SQLSTATE_GENERAL,1000,Any() );
1290
1291 // m_pCacheSet->absolute(m_nPosition);
1292 m_pCacheSet->deleteRow(*m_aMatrixIter,m_aUpdateTable);
1293 if ( !m_pCacheSet->rowDeleted() )
1294 return false;
1295
1296 --m_nRowCount;
1297 OSL_ENSURE(((m_nPosition - m_nStartPos) - 1) < (sal_Int32)m_pMatrix->size(),"Position is behind end()!");
1298 ORowSetMatrix::iterator aPos = calcPosition();
1299 (*aPos) = NULL;
1300 // (*m_pMatrix)[(m_nPosition - m_nStartPos)] = NULL; // set the deleted row to NULL
1301
1302
1303 ORowSetMatrix::iterator aEnd = m_pMatrix->end();
1304 for(++aPos;aPos != aEnd && aPos->isValid();++aPos)
1305 {
1306 *(aPos-1) = *aPos;
1307 (*aPos) = NULL;
1308 }
1309 m_aMatrixIter = m_pMatrix->end();
1310
1311 --m_nPosition;
1312 return true;
1313 }
1314 // -------------------------------------------------------------------------
1315 void ORowSetCache::cancelRowUpdates( )
1316 {
1317 m_bNew = m_bModified = sal_False;
1318 if(!m_nPosition)
1319 {
1320 OSL_ENSURE(0,"cancelRowUpdates:Invalid positions pos == 0");
1321 ::dbtools::throwFunctionSequenceException(NULL);
1322 }
1323
1324 if(m_pCacheSet->absolute(m_nPosition))
1325 m_pCacheSet->fillValueRow(*m_aMatrixIter,m_nPosition);
1326 else
1327 {
1328 OSL_ENSURE(0,"cancelRowUpdates couldn't position right with absolute");
1329 ::dbtools::throwFunctionSequenceException(NULL);
1330 }
1331 }
1332 // -------------------------------------------------------------------------
1333 void ORowSetCache::moveToInsertRow( )
1334 {
1335 m_bNew = sal_True;
1336 m_bUpdated = m_bAfterLast = sal_False;
1337
1338 m_aInsertRow = m_pInsertMatrix->begin();
1339 if(!m_aInsertRow->isValid())
1340 *m_aInsertRow = new ORowSetValueVector(m_xMetaData->getColumnCount());
1341
1342 // we don't unbound the bookmark column
1343 ORowSetValueVector::Vector::iterator aIter = (*m_aInsertRow)->get().begin()+1;
1344 ORowSetValueVector::Vector::iterator aEnd = (*m_aInsertRow)->get().end();
1345 for(;aIter != aEnd;++aIter)
1346 {
1347 aIter->setBound(sal_False);
1348 aIter->setModified(sal_False);
1349 aIter->setNull();
1350 }
1351 }
1352 // -------------------------------------------------------------------------
1353 ORowSetCacheIterator ORowSetCache::createIterator(ORowSetBase* _pRowSet)
1354 {
1355
1356 ORowSetCacheIterator_Helper aHelper;
1357 aHelper.aIterator = m_pMatrix->end();
1358 aHelper.pRowSet = _pRowSet;
1359 return ORowSetCacheIterator(m_aCacheIterators.insert(m_aCacheIterators.begin(),ORowSetCacheMap::value_type(m_aCacheIterators.size()+1,aHelper)),this,_pRowSet);
1360 }
1361 // -----------------------------------------------------------------------------
1362 void ORowSetCache::deleteIterator(const ORowSetBase* _pRowSet)
1363 {
1364 ORowSetCacheMap::iterator aCacheIter = m_aCacheIterators.begin();
1365 for(;aCacheIter != m_aCacheIterators.end();)
1366 {
1367 if ( aCacheIter->second.pRowSet == _pRowSet )
1368 {
1369 m_aCacheIterators.erase(aCacheIter);
1370 aCacheIter = m_aCacheIterators.begin();
1371 } // if ( aCacheIter->second.pRowSet == _pRowSet )
1372 else
1373 ++aCacheIter;
1374 }
1375 }
1376 // -----------------------------------------------------------------------------
1377 void ORowSetCache::rotateCacheIterator(ORowSetMatrix::difference_type _nDist)
1378 {
1379 if(_nDist)
1380 {
1381 // now correct the iterator in our iterator vector
1382 ORowSetCacheMap::iterator aCacheIter = m_aCacheIterators.begin();
1383 ORowSetCacheMap::iterator aCacheEnd = m_aCacheIterators.end();
1384 for(;aCacheIter != aCacheEnd;++aCacheIter)
1385 {
1386 if ( !aCacheIter->second.pRowSet->isInsertRow()
1387 && aCacheIter->second.aIterator != m_pMatrix->end() && !m_bModified )
1388 {
1389 ptrdiff_t nDist = (aCacheIter->second.aIterator - m_pMatrix->begin());
1390 if(nDist < _nDist)
1391 {
1392 aCacheIter->second.aIterator = m_pMatrix->end();
1393 }
1394 else
1395 {
1396 OSL_ENSURE((aCacheIter->second.aIterator - m_pMatrix->begin()) >= _nDist,"Invalid Dist value!");
1397 aCacheIter->second.aIterator -= _nDist;
1398 OSL_ENSURE(aCacheIter->second.aIterator >= m_pMatrix->begin()
1399 && aCacheIter->second.aIterator < m_pMatrix->end(),"Iterator out of area!");
1400 }
1401 }
1402 }
1403 }
1404 }
1405 // -------------------------------------------------------------------------
1406 void ORowSetCache::setUpdateIterator(const ORowSetMatrix::iterator& _rOriginalRow)
1407 {
1408 m_aInsertRow = m_pInsertMatrix->begin();
1409 if(!m_aInsertRow->isValid())
1410 *m_aInsertRow = new ORowSetValueVector(m_xMetaData->getColumnCount());
1411
1412 (*(*m_aInsertRow)) = (*(*_rOriginalRow));
1413 // we don't unbound the bookmark column
1414 ORowSetValueVector::Vector::iterator aIter = (*m_aInsertRow)->get().begin();
1415 ORowSetValueVector::Vector::iterator aEnd = (*m_aInsertRow)->get().end();
1416 for(;aIter != aEnd;++aIter)
1417 aIter->setModified(sal_False);
1418 }
1419 // -----------------------------------------------------------------------------
1420 void ORowSetCache::checkPositionFlags()
1421 {
1422 if(m_bRowCountFinal)
1423 {
1424 m_bAfterLast = m_nPosition > m_nRowCount;
1425 if(m_bAfterLast)
1426 m_nPosition = 0;//m_nRowCount;
1427 }
1428 }
1429 // -----------------------------------------------------------------------------
1430 void ORowSetCache::checkUpdateConditions(sal_Int32 columnIndex)
1431 {
1432 if(m_bAfterLast || columnIndex >= (sal_Int32)(*m_aInsertRow)->get().size())
1433 throwFunctionSequenceException(m_xSet.get());
1434 }
1435 //------------------------------------------------------------------------------
1436 sal_Bool ORowSetCache::checkInnerJoin(const ::connectivity::OSQLParseNode *pNode,const Reference< XConnection>& _xConnection,const ::rtl::OUString& _sUpdateTableName)
1437 {
1438 sal_Bool bOk = sal_False;
1439 if (pNode->count() == 3 && // Ausdruck is geklammert
1440 SQL_ISPUNCTUATION(pNode->getChild(0),"(") &&
1441 SQL_ISPUNCTUATION(pNode->getChild(2),")"))
1442 {
1443 bOk = checkInnerJoin(pNode->getChild(1),_xConnection,_sUpdateTableName);
1444 }
1445 else if ((SQL_ISRULE(pNode,search_condition) || SQL_ISRULE(pNode,boolean_term)) && // AND/OR-Verknuepfung:
1446 pNode->count() == 3)
1447 {
1448 // nur AND Verknüpfung zulassen
1449 if ( SQL_ISTOKEN(pNode->getChild(1),AND) )
1450 bOk = checkInnerJoin(pNode->getChild(0),_xConnection,_sUpdateTableName)
1451 && checkInnerJoin(pNode->getChild(2),_xConnection,_sUpdateTableName);
1452 }
1453 else if (SQL_ISRULE(pNode,comparison_predicate))
1454 {
1455 // only the comparison of columns is allowed
1456 DBG_ASSERT(pNode->count() == 3,"checkInnerJoin: Fehler im Parse Tree");
1457 if (!(SQL_ISRULE(pNode->getChild(0),column_ref) &&
1458 SQL_ISRULE(pNode->getChild(2),column_ref) &&
1459 pNode->getChild(1)->getNodeType() == SQL_NODE_EQUAL))
1460 {
1461 bOk = sal_False;
1462 }
1463 ::rtl::OUString sColumnName,sTableRange;
1464 OSQLParseTreeIterator::getColumnRange( pNode->getChild(0), _xConnection, sColumnName, sTableRange );
1465 bOk = sTableRange == _sUpdateTableName;
1466 if ( !bOk )
1467 {
1468 OSQLParseTreeIterator::getColumnRange( pNode->getChild(2), _xConnection, sColumnName, sTableRange );
1469 bOk = sTableRange == _sUpdateTableName;
1470 }
1471 }
1472 return bOk;
1473 }
1474 // -----------------------------------------------------------------------------
1475 sal_Bool ORowSetCache::checkJoin(const Reference< XConnection>& _xConnection,
1476 const Reference< XSingleSelectQueryAnalyzer >& _xAnalyzer,
1477 const ::rtl::OUString& _sUpdateTableName )
1478 {
1479 sal_Bool bOk = sal_False;
1480 ::rtl::OUString sSql = _xAnalyzer->getQuery();
1481 ::rtl::OUString sErrorMsg;
1482 ::connectivity::OSQLParser aSqlParser( m_aContext.getLegacyServiceFactory() );
1483 ::std::auto_ptr< ::connectivity::OSQLParseNode> pSqlParseNode( aSqlParser.parseTree(sErrorMsg,sSql));
1484 if ( pSqlParseNode.get() && SQL_ISRULE(pSqlParseNode, select_statement) )
1485 {
1486 OSQLParseNode* pTableRefCommalist = pSqlParseNode->getByRule(::connectivity::OSQLParseNode::table_ref_commalist);
1487 OSL_ENSURE(pTableRefCommalist,"NO tables why!?");
1488 if(pTableRefCommalist && pTableRefCommalist->count() == 1)
1489 {
1490 // we found only one element so it must some kind of join here
1491 OSQLParseNode* pJoin = pTableRefCommalist->getByRule(::connectivity::OSQLParseNode::qualified_join);
1492 if(pJoin)
1493 { // we are only intereseted in qualified joins like RIGHT or LEFT
1494 OSQLParseNode* pJoinType = pJoin->getChild(1);
1495 OSQLParseNode* pOuterType = NULL;
1496 if(SQL_ISRULE(pJoinType,join_type) && pJoinType->count() == 2)
1497 pOuterType = pJoinType->getChild(0);
1498 else if(SQL_ISRULE(pJoinType,outer_join_type))
1499 pOuterType = pJoinType;
1500
1501 sal_Bool bCheck = sal_False;
1502 sal_Bool bLeftSide = sal_False;
1503 if(pOuterType)
1504 { // found outer join
1505 bLeftSide = SQL_ISTOKEN(pOuterType->getChild(0),LEFT);
1506 bCheck = bLeftSide || SQL_ISTOKEN(pOuterType->getChild(0),RIGHT);
1507 }
1508
1509 if(bCheck)
1510 { // here we know that we have to check on which side our table resides
1511 const OSQLParseNode* pTableRef = pJoin->getByRule(::connectivity::OSQLParseNode::qualified_join);
1512 if(bLeftSide)
1513 pTableRef = pJoin->getChild(0);
1514 else
1515 pTableRef = pJoin->getChild(3);
1516 OSL_ENSURE(SQL_ISRULE(pTableRef,table_ref),"Must be a tableref here!");
1517
1518 ::rtl::OUString sTableRange = OSQLParseNode::getTableRange(pTableRef);
1519 if(!sTableRange.getLength())
1520 pTableRef->getChild(0)->parseNodeToStr( sTableRange, _xConnection, NULL, sal_False, sal_False );
1521 bOk = sTableRange == _sUpdateTableName;
1522 }
1523 }
1524 }
1525 else
1526 {
1527 OSQLParseNode* pWhereOpt = pSqlParseNode->getChild(3)->getChild(1);
1528 if ( pWhereOpt && !pWhereOpt->isLeaf() )
1529 bOk = checkInnerJoin(pWhereOpt->getChild(1),_xConnection,_sUpdateTableName);
1530 }
1531 }
1532 return bOk;
1533 }
1534 // -----------------------------------------------------------------------------
1535 void ORowSetCache::clearInsertRow()
1536 {
1537 // we don't unbound the bookmark column
1538 if ( m_aInsertRow != m_pInsertMatrix->end() && m_aInsertRow->isValid() )
1539 {
1540 ORowSetValueVector::Vector::iterator aIter = (*m_aInsertRow)->get().begin()+1;
1541 ORowSetValueVector::Vector::iterator aEnd = (*m_aInsertRow)->get().end();
1542 for(;aIter != aEnd;++aIter)
1543 {
1544 aIter->setBound(sal_False);
1545 aIter->setModified(sal_False);
1546 aIter->setNull();
1547 } // for(;aIter != (*m_aInsertRow)->end();++aIter)
1548 }
1549 }
1550 // -----------------------------------------------------------------------------
1551 ORowSetMatrix::iterator ORowSetCache::calcPosition() const
1552 {
1553 sal_Int32 nValue = (m_nPosition - m_nStartPos) - 1;
1554 CHECK_MATRIX_POS(nValue);
1555 return ( nValue < 0 || nValue >= static_cast<sal_Int32>(m_pMatrix->size()) ) ? m_pMatrix->end() : (m_pMatrix->begin() + nValue);
1556 }
1557 // -----------------------------------------------------------------------------
1558
1559 TORowSetOldRowHelperRef ORowSetCache::registerOldRow()
1560 {
1561 TORowSetOldRowHelperRef pRef = new ORowSetOldRowHelper(ORowSetRow());
1562 m_aOldRows.push_back(pRef);
1563 return pRef;
1564 }
1565 // -----------------------------------------------------------------------------
1566 void ORowSetCache::deregisterOldRow(const TORowSetOldRowHelperRef& _rRow)
1567 {
1568 TOldRowSetRows::iterator aOldRowEnd = m_aOldRows.end();
1569 for (TOldRowSetRows::iterator aOldRowIter = m_aOldRows.begin(); aOldRowIter != aOldRowEnd; ++aOldRowIter)
1570 {
1571 if ( aOldRowIter->getBodyPtr() == _rRow.getBodyPtr() )
1572 {
1573 m_aOldRows.erase(aOldRowIter);
1574 break;
1575 }
1576
1577 }
1578 }
1579 // -----------------------------------------------------------------------------
1580 sal_Bool ORowSetCache::reFillMatrix(sal_Int32 _nNewStartPos,sal_Int32 _nNewEndPos)
1581 {
1582 TOldRowSetRows::iterator aOldRowEnd = m_aOldRows.end();
1583 for (TOldRowSetRows::iterator aOldRowIter = m_aOldRows.begin(); aOldRowIter != aOldRowEnd; ++aOldRowIter)
1584 {
1585 if ( aOldRowIter->isValid() && aOldRowIter->getBody().getRow().isValid() )
1586 aOldRowIter->getBody().setRow(new ORowSetValueVector(aOldRowIter->getBody().getRow().getBody()) );
1587 }
1588 sal_Int32 nNewSt = _nNewStartPos;
1589 sal_Bool bRet = fillMatrix(nNewSt,_nNewEndPos);
1590 m_nStartPos = nNewSt - 1;
1591 rotateCacheIterator(static_cast<sal_Int16>(m_nFetchSize+1)); // forces that every iterator will be set to null
1592 return bRet;
1593 }
1594 // -----------------------------------------------------------------------------
1595 sal_Bool ORowSetCache::fill(ORowSetMatrix::iterator& _aIter,const ORowSetMatrix::iterator& _aEnd,sal_Int32& _nPos,sal_Bool _bCheck)
1596 {
1597 sal_Int32 nColumnCount = m_xMetaData->getColumnCount();
1598 for(; _bCheck && _aIter != _aEnd;)
1599 {
1600 if ( !_aIter->isValid() )
1601 *_aIter = new ORowSetValueVector(nColumnCount);
1602 else
1603 {
1604 TOldRowSetRows::iterator aOldRowEnd = m_aOldRows.end();
1605 for (TOldRowSetRows::iterator aOldRowIter = m_aOldRows.begin(); aOldRowIter != aOldRowEnd; ++aOldRowIter)
1606 {
1607 if ( aOldRowIter->getBody().getRow().isEqualBody(*_aIter) )
1608 *_aIter = new ORowSetValueVector(nColumnCount);
1609 }
1610 }
1611 m_pCacheSet->fillValueRow(*_aIter++,++_nPos);
1612 _bCheck = m_pCacheSet->next();
1613 }
1614 return _bCheck;
1615 }
1616 // -----------------------------------------------------------------------------
1617
1618
1619
1620
1621
vba interoperability for OOo