?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nss: upgrade to release 3.73
[LibreOffice.git] / connectivity / source / drivers / file / FResultSet.cxx
blob5cf5d1ae862d9fe086a4c978e14a8d487b036ea5
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <file/FResultSet.hxx>
22 #include <sqlbison.hxx>
23 #include <file/FResultSetMetaData.hxx>
24 #include <com/sun/star/sdbc/DataType.hpp>
25 #include <com/sun/star/beans/PropertyAttribute.hpp>
26 #include <com/sun/star/container/XIndexAccess.hpp>
27 #include <comphelper/sequence.hxx>
28 #include <comphelper/servicehelper.hxx>
29 #include <cppuhelper/typeprovider.hxx>
30 #include <connectivity/dbtools.hxx>
31 #include <cppuhelper/propshlp.hxx>
32 #include <sal/log.hxx>
33 #include <iterator>
34 #include <com/sun/star/sdbc/ResultSetType.hpp>
35 #include <com/sun/star/sdbc/FetchDirection.hpp>
36 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
37 #include <com/sun/star/sdbcx/XIndexesSupplier.hpp>
38
39 #include <algorithm>
40 #include <connectivity/dbexception.hxx>
41 #include <comphelper/types.hxx>
42 #include <resource/sharedresources.hxx>
43 #include <strings.hrc>
44 #include <tools/diagnose_ex.h>
45
46 using namespace ::comphelper;
47 using namespace connectivity;
48 using namespace connectivity::file;
49 using namespace ::cppu;
50 using namespace dbtools;
51 using namespace com::sun::star::uno;
52 using namespace com::sun::star::lang;
53 using namespace com::sun::star::beans;
54 using namespace com::sun::star::sdbc;
55 using namespace com::sun::star::sdbcx;
56 using namespace com::sun::star::container;
57
58 namespace
59 {
60 void lcl_throwError(const char* pErrorId, const css::uno::Reference< css::uno::XInterface>& _xContext)
61 {
62 ::connectivity::SharedResources aResources;
63 const OUString sMessage = aResources.getResourceString(pErrorId);
64 ::dbtools::throwGenericSQLException(sMessage ,_xContext);
65 }
66 }
67
68 IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.drivers.file.ResultSet","com.sun.star.sdbc.ResultSet");
69
70 OResultSet::OResultSet(OStatement_Base* pStmt,OSQLParseTreeIterator& _aSQLIterator) : OResultSet_BASE(m_aMutex)
71 ,::comphelper::OPropertyContainer(OResultSet_BASE::rBHelper)
72 ,m_aSkipDeletedSet(this)
73 ,m_pParseTree(pStmt->getParseTree())
74 ,m_pSQLAnalyzer(nullptr)
75 ,m_aSQLIterator(_aSQLIterator)
76 ,m_nFetchSize(0)
77 ,m_nResultSetType(ResultSetType::SCROLL_INSENSITIVE)
78 ,m_nFetchDirection(FetchDirection::FORWARD)
79 ,m_nResultSetConcurrency(ResultSetConcurrency::UPDATABLE)
80 ,m_xStatement(*pStmt)
81 ,m_nRowPos(-1)
82 ,m_nFilePos(0)
83 ,m_nLastVisitedPos(-1)
84 ,m_nRowCountResult(-1)
85 ,m_nColumnCount(0)
86 ,m_bWasNull(false)
87 ,m_bInserted(false)
88 ,m_bRowUpdated(false)
89 ,m_bRowInserted(false)
90 ,m_bRowDeleted(false)
91 ,m_bShowDeleted(pStmt->getOwnConnection()->showDeleted())
92 ,m_bIsCount(false)
93 {
94 osl_atomic_increment( &m_refCount );
95 m_bIsCount = (m_pParseTree &&
96 m_pParseTree->count() > 2 &&
97 SQL_ISRULE(m_pParseTree->getChild(2),scalar_exp_commalist) &&
98 SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0),derived_column) &&
99 SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0)->getChild(0),general_set_fct) &&
100 m_pParseTree->getChild(2)->getChild(0)->getChild(0)->count() == 4
101 );
102
103 m_nResultSetConcurrency = isCount() ? ResultSetConcurrency::READ_ONLY : ResultSetConcurrency::UPDATABLE;
104 construct();
105 m_aSkipDeletedSet.SetDeletedVisible(m_bShowDeleted);
106 osl_atomic_decrement( &m_refCount );
107 }
108
109
110 OResultSet::~OResultSet()
111 {
112 osl_atomic_increment( &m_refCount );
113 disposing();
114 }
115
116 void OResultSet::construct()
117 {
118 registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE), PROPERTY_ID_FETCHSIZE, 0,&m_nFetchSize, ::cppu::UnoType<sal_Int32>::get());
119 registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE), PROPERTY_ID_RESULTSETTYPE, PropertyAttribute::READONLY,&m_nResultSetType, ::cppu::UnoType<sal_Int32>::get());
120 registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION), PROPERTY_ID_FETCHDIRECTION, 0,&m_nFetchDirection, ::cppu::UnoType<sal_Int32>::get());
121 registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY), PROPERTY_ID_RESULTSETCONCURRENCY,PropertyAttribute::READONLY,&m_nResultSetConcurrency, ::cppu::UnoType<sal_Int32>::get());
122 }
123
124 void OResultSet::disposing()
125 {
126 OPropertySetHelper::disposing();
127
128 ::osl::MutexGuard aGuard(m_aMutex);
129 m_xStatement.clear();
130 m_xMetaData.clear();
131 m_pParseTree = nullptr;
132 m_xColNames.clear();
133 m_xColumns = nullptr;
134 m_xColsIdx.clear();
135
136 Reference<XComponent> xComp = m_pTable.get();
137 if ( xComp.is() )
138 xComp->removeEventListener(this);
139 m_pTable.clear();
140
141 m_pFileSet = nullptr;
142 m_pSortIndex.reset();
143
144 if(m_aInsertRow.is())
145 m_aInsertRow->clear();
146
147 m_aSkipDeletedSet.clear();
148 }
149
150 Any SAL_CALL OResultSet::queryInterface( const Type & rType )
151 {
152 Any aRet = OPropertySetHelper::queryInterface(rType);
153 return aRet.hasValue() ? aRet : OResultSet_BASE::queryInterface(rType);
154 }
155
156 Sequence< Type > SAL_CALL OResultSet::getTypes( )
157 {
158 ::osl::MutexGuard aGuard( m_aMutex );
159
160 OTypeCollection aTypes( cppu::UnoType<css::beans::XMultiPropertySet>::get(),
161 cppu::UnoType<css::beans::XPropertySet>::get(),
162 cppu::UnoType<css::beans::XPropertySet>::get());
163
164 return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
165 }
166
167
168 sal_Int32 SAL_CALL OResultSet::findColumn( const OUString& columnName )
169 {
170 ::osl::MutexGuard aGuard( m_aMutex );
171 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
172
173
174 Reference< XResultSetMetaData > xMeta = getMetaData();
175 sal_Int32 nLen = xMeta->getColumnCount();
176 sal_Int32 i = 1;
177 for(;i<=nLen;++i)
178 {
179 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
180 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
181 return i;
182 }
183
184 ::dbtools::throwInvalidColumnException( columnName, *this );
185 assert(false);
186 return 0; // Never reached
187 }
188
189 const ORowSetValue& OResultSet::getValue(sal_Int32 columnIndex)
190 {
191 ::osl::MutexGuard aGuard( m_aMutex );
192 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
193
194 checkIndex(columnIndex );
195
196
197 m_bWasNull = (*m_aSelectRow)[columnIndex]->getValue().isNull();
198 return *(*m_aSelectRow)[columnIndex];
199 }
200
201 void OResultSet::checkIndex(sal_Int32 columnIndex )
202 {
203 if ( columnIndex <= 0
204 || columnIndex >= m_nColumnCount )
205 ::dbtools::throwInvalidIndexException(*this);
206 }
207
208 Reference< css::io::XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ )
209 {
210 return nullptr;
211 }
212
213 Reference< css::io::XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ )
214 {
215 return nullptr;
216 }
217
218
219 sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 columnIndex )
220 {
221 return bool(getValue(columnIndex));
222 }
223
224
225 sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 columnIndex )
226 {
227 return getValue(columnIndex);
228 }
229
230
231 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 columnIndex )
232 {
233 return getValue(columnIndex);
234 }
235
236
237 css::util::Date SAL_CALL OResultSet::getDate( sal_Int32 columnIndex )
238 {
239 return getValue(columnIndex);
240 }
241
242
243 double SAL_CALL OResultSet::getDouble( sal_Int32 columnIndex )
244 {
245 return getValue(columnIndex);
246 }
247
248
249 float SAL_CALL OResultSet::getFloat( sal_Int32 columnIndex )
250 {
251 return getValue(columnIndex);
252 }
253
254
255 sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 columnIndex )
256 {
257 return getValue(columnIndex);
258 }
259
260
261 sal_Int32 SAL_CALL OResultSet::getRow( )
262 {
263 ::osl::MutexGuard aGuard( m_aMutex );
264 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
265
266 OSL_ENSURE((m_bShowDeleted || !m_aRow->isDeleted()),"getRow called for deleted row");
267
268 return m_aSkipDeletedSet.getMappedPosition((*m_aRow)[0]->getValue());
269 }
270
271
272 sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 columnIndex )
273 {
274 return getValue(columnIndex);
275 }
276
277
278 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData( )
279 {
280 ::osl::MutexGuard aGuard( m_aMutex );
281 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
282
283
284 if(!m_xMetaData.is())
285 m_xMetaData = new OResultSetMetaData(m_xColumns,m_aSQLIterator.getTables().begin()->first,m_pTable.get());
286 return m_xMetaData;
287 }
288
289 Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ )
290 {
291 return nullptr;
292 }
293
294
295 Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ )
296 {
297 return nullptr;
298 }
299
300 Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ )
301 {
302 return nullptr;
303 }
304
305
306 Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ )
307 {
308 return nullptr;
309 }
310
311
312 Any SAL_CALL OResultSet::getObject( sal_Int32 columnIndex, const Reference< css::container::XNameAccess >& /*typeMap*/ )
313 {
314 return getValue(columnIndex).makeAny();
315 }
316
317
318 sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 columnIndex )
319 {
320 return getValue(columnIndex);
321 }
322
323 OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex )
324 {
325 return getValue(columnIndex);
326 }
327
328 css::util::Time SAL_CALL OResultSet::getTime( sal_Int32 columnIndex )
329 {
330 return getValue(columnIndex);
331 }
332
333 css::util::DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 columnIndex )
334 {
335 return getValue(columnIndex);
336 }
337
338
339 sal_Bool SAL_CALL OResultSet::isAfterLast( )
340 {
341 ::osl::MutexGuard aGuard( m_aMutex );
342 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
343
344
345 return m_nRowPos == sal_Int32(m_pFileSet->size());
346 }
347
348 sal_Bool SAL_CALL OResultSet::isFirst( )
349 {
350 ::osl::MutexGuard aGuard( m_aMutex );
351 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
352
353
354 return m_nRowPos == 0;
355 }
356
357 sal_Bool SAL_CALL OResultSet::isLast( )
358 {
359 ::osl::MutexGuard aGuard( m_aMutex );
360 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
361
362
363 return m_nRowPos == sal_Int32(m_pFileSet->size() - 1);
364 }
365
366 void SAL_CALL OResultSet::beforeFirst( )
367 {
368 ::osl::MutexGuard aGuard( m_aMutex );
369 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
370
371
372 if(first())
373 previous();
374 }
375
376 void SAL_CALL OResultSet::afterLast( )
377 {
378 ::osl::MutexGuard aGuard( m_aMutex );
379 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
380
381
382 if(last())
383 next();
384 }
385
386
387 void SAL_CALL OResultSet::close( )
388 {
389 dispose();
390 }
391
392
393 sal_Bool SAL_CALL OResultSet::first( )
394 {
395 ::osl::MutexGuard aGuard( m_aMutex );
396 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
397 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::FIRST,1,true);
398 }
399
400
401 sal_Bool SAL_CALL OResultSet::last( )
402 {
403 // here I know definitely that I stand on the last record
404 ::osl::MutexGuard aGuard( m_aMutex );
405 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
406 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::LAST,1,true);
407 }
408
409 sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row )
410 {
411 ::osl::MutexGuard aGuard( m_aMutex );
412 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
413 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::ABSOLUTE1,row,true);
414 }
415
416 sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row )
417 {
418 ::osl::MutexGuard aGuard( m_aMutex );
419 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
420 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::RELATIVE1,row,true);
421 }
422
423 sal_Bool SAL_CALL OResultSet::previous( )
424 {
425 ::osl::MutexGuard aGuard( m_aMutex );
426 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
427 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::PRIOR,0,true);
428 }
429
430 Reference< XInterface > SAL_CALL OResultSet::getStatement( )
431 {
432 ::osl::MutexGuard aGuard( m_aMutex );
433 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
434
435
436 return m_xStatement;
437 }
438
439
440 sal_Bool SAL_CALL OResultSet::rowDeleted( )
441 {
442 ::osl::MutexGuard aGuard( m_aMutex );
443 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
444
445
446 return m_bRowDeleted;
447 }
448
449 sal_Bool SAL_CALL OResultSet::rowInserted( )
450 { ::osl::MutexGuard aGuard( m_aMutex );
451 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
452
453
454 return m_bRowInserted;
455 }
456
457 sal_Bool SAL_CALL OResultSet::rowUpdated( )
458 {
459 ::osl::MutexGuard aGuard( m_aMutex );
460 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
461
462
463 return m_bRowUpdated;
464 }
465
466
467 sal_Bool SAL_CALL OResultSet::isBeforeFirst( )
468 {
469 ::osl::MutexGuard aGuard( m_aMutex );
470 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
471
472
473 return m_nRowPos == -1;
474 }
475
476 sal_Bool SAL_CALL OResultSet::next( )
477 {
478 ::osl::MutexGuard aGuard( m_aMutex );
479 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
480
481 return m_pTable.is() && m_aSkipDeletedSet.skipDeleted(IResultSetHelper::NEXT,1,true);
482 }
483
484
485 sal_Bool SAL_CALL OResultSet::wasNull( )
486 {
487 ::osl::MutexGuard aGuard( m_aMutex );
488 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
489
490 return m_bWasNull;
491 }
492
493
494 void SAL_CALL OResultSet::cancel( )
495 {
496 }
497
498 void SAL_CALL OResultSet::clearWarnings( )
499 {
500 }
501
502 Any SAL_CALL OResultSet::getWarnings( )
503 {
504 return Any();
505 }
506
507 void SAL_CALL OResultSet::insertRow( )
508 {
509 ::osl::MutexGuard aGuard( m_aMutex );
510 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
511
512
513 if(!m_bInserted || !m_pTable.is())
514 throwFunctionSequenceException(*this);
515
516 // we know that we append new rows at the end
517 // so we have to know where the end is
518 (void)m_aSkipDeletedSet.skipDeleted(IResultSetHelper::LAST,1,false);
519 m_bRowInserted = m_pTable->InsertRow(*m_aInsertRow, m_xColsIdx);
520 if(m_bRowInserted && m_pFileSet.is())
521 {
522 sal_Int32 nPos = (*m_aInsertRow)[0]->getValue();
523 m_pFileSet->push_back(nPos);
524 *(*m_aInsertRow)[0] = sal_Int32(m_pFileSet->size());
525 clearInsertRow();
526
527 m_aSkipDeletedSet.insertNewPosition((*m_aRow)[0]->getValue());
528 }
529 }
530
531 void SAL_CALL OResultSet::updateRow( )
532 {
533 ::osl::MutexGuard aGuard( m_aMutex );
534 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
535
536 if(!m_pTable.is() || m_pTable->isReadOnly())
537 lcl_throwError(STR_TABLE_READONLY,*this);
538
539 m_bRowUpdated = m_pTable->UpdateRow(*m_aInsertRow, m_aRow,m_xColsIdx);
540 *(*m_aInsertRow)[0] = static_cast<sal_Int32>((*m_aRow)[0]->getValue());
541
542 clearInsertRow();
543 }
544
545 void SAL_CALL OResultSet::deleteRow()
546 {
547 ::osl::MutexGuard aGuard( m_aMutex );
548 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
549
550 if(!m_pTable.is() || m_pTable->isReadOnly())
551 lcl_throwError(STR_TABLE_READONLY,*this);
552 if (m_bShowDeleted)
553 lcl_throwError(STR_DELETE_ROW,*this);
554 if(m_aRow->isDeleted())
555 lcl_throwError(STR_ROW_ALREADY_DELETED,*this);
556
557 sal_Int32 nPos = static_cast<sal_Int32>((*m_aRow)[0]->getValue());
558 m_bRowDeleted = m_pTable->DeleteRow(*m_xColumns);
559 if(m_bRowDeleted && m_pFileSet.is())
560 {
561 m_aRow->setDeleted(true);
562 // don't touch the m_pFileSet member here
563 m_aSkipDeletedSet.deletePosition(nPos);
564 }
565 }
566
567 void SAL_CALL OResultSet::cancelRowUpdates( )
568 {
569 ::osl::MutexGuard aGuard( m_aMutex );
570 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
571
572
573 m_bInserted = false;
574 m_bRowUpdated = false;
575 m_bRowInserted = false;
576 m_bRowDeleted = false;
577
578 if(m_aInsertRow.is())
579 {
580 OValueRefVector::iterator aIter = m_aInsertRow->begin()+1;
581 for(;aIter != m_aInsertRow->end();++aIter)
582 {
583 (*aIter)->setBound(false);
584 (*aIter)->setNull();
585 }
586 }
587 }
588
589
590 void SAL_CALL OResultSet::moveToInsertRow( )
591 {
592 ::osl::MutexGuard aGuard( m_aMutex );
593 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
594
595 if(!m_pTable.is() || m_pTable->isReadOnly())
596 lcl_throwError(STR_TABLE_READONLY,*this);
597
598 m_bInserted = true;
599
600 OValueRefVector::iterator aIter = m_aInsertRow->begin()+1;
601 for(;aIter != m_aInsertRow->end();++aIter)
602 {
603 (*aIter)->setBound(false);
604 (*aIter)->setNull();
605 }
606 }
607
608
609 void SAL_CALL OResultSet::moveToCurrentRow( )
610 {
611 }
612
613 void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x)
614 {
615 ::osl::MutexGuard aGuard( m_aMutex );
616 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
617
618 checkIndex(columnIndex );
619 columnIndex = mapColumn(columnIndex);
620
621 (*m_aInsertRow)[columnIndex]->setBound(true);
622 *(*m_aInsertRow)[columnIndex] = x;
623 }
624
625
626 void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex )
627 {
628 ORowSetValue aEmpty;
629 updateValue(columnIndex,aEmpty);
630 }
631
632
633 void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x )
634 {
635 updateValue(columnIndex, static_cast<bool>(x));
636 }
637
638 void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x )
639 {
640 updateValue(columnIndex,x);
641 }
642
643
644 void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x )
645 {
646 updateValue(columnIndex,x);
647 }
648
649 void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x )
650 {
651 updateValue(columnIndex,x);
652 }
653
654 void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ )
655 {
656 ::dbtools::throwFeatureNotImplementedSQLException( "XRowUpdate::updateLong", *this );
657 }
658
659 void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x )
660 {
661 updateValue(columnIndex,x);
662 }
663
664
665 void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x )
666 {
667 updateValue(columnIndex,x);
668 }
669
670 void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const OUString& x )
671 {
672 updateValue(columnIndex,x);
673 }
674
675 void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x )
676 {
677 updateValue(columnIndex,x);
678 }
679
680 void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const css::util::Date& x )
681 {
682 updateValue(columnIndex,x);
683 }
684
685
686 void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const css::util::Time& x )
687 {
688 updateValue(columnIndex,x);
689 }
690
691
692 void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const css::util::DateTime& x )
693 {
694 updateValue(columnIndex,x);
695 }
696
697
698 void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length )
699 {
700 ::osl::MutexGuard aGuard( m_aMutex );
701 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
702
703 if(!x.is())
704 ::dbtools::throwFunctionSequenceException(*this);
705
706 Sequence<sal_Int8> aSeq;
707 x->readBytes(aSeq,length);
708 updateValue(columnIndex,aSeq);
709 }
710
711 void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length )
712 {
713 updateBinaryStream(columnIndex,x,length);
714 }
715
716 void SAL_CALL OResultSet::refreshRow( )
717 {
718 ::osl::MutexGuard aGuard( m_aMutex );
719 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
720 }
721
722 void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x )
723 {
724 if (!::dbtools::implUpdateObject(this, columnIndex, x))
725 throw SQLException();
726 }
727
728
729 void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ )
730 {
731 if (!::dbtools::implUpdateObject(this, columnIndex, x))
732 throw SQLException();
733 }
734
735 IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
736 {
737 Sequence< Property > aProps;
738 describeProperties(aProps);
739 return new ::cppu::OPropertyArrayHelper(aProps);
740 }
741
742 IPropertyArrayHelper & OResultSet::getInfoHelper()
743 {
744 return *getArrayHelper();
745 }
746
747
748 bool OResultSet::ExecuteRow(IResultSetHelper::Movement eFirstCursorPosition,
749 sal_Int32 nFirstOffset,
750 bool bEvaluate,
751 bool bRetrieveData)
752 {
753 OSL_ENSURE(m_pSQLAnalyzer,"OResultSet::ExecuteRow: Analyzer isn't set!");
754
755 // For further Fetch-Operations this information may possibly be changed ...
756 IResultSetHelper::Movement eCursorPosition = eFirstCursorPosition;
757 sal_Int32 nOffset = nFirstOffset;
758
759 if (!m_pTable.is())
760 return false;
761
762 const OSQLColumns & rTableCols = *(m_pTable->getTableColumns());
763 bool bHasRestriction = m_pSQLAnalyzer->hasRestriction();
764 again:
765
766 // protect from reading over the end when somebody is inserting while we are reading
767 // this method works only for dBase at the moment!!!
768 if (eCursorPosition == IResultSetHelper::NEXT && m_nFilePos == m_nLastVisitedPos)
769 {
770 return false;
771 }
772
773 if (!m_pTable.is() || !m_pTable->seekRow(eCursorPosition, nOffset, m_nFilePos))
774 {
775 return false;
776 }
777
778 if (!bEvaluate) // If no evaluation runs, then just fill the results-row
779 {
780 m_pTable->fetchRow(m_aRow,rTableCols, bRetrieveData);
781 }
782 else
783 {
784 m_pTable->fetchRow(m_aEvaluateRow, rTableCols, bRetrieveData || bHasRestriction);
785
786 if ( ( !m_bShowDeleted
787 && m_aEvaluateRow->isDeleted()
788 )
789 || ( bHasRestriction
790 && !m_pSQLAnalyzer->evaluateRestriction()
791 )
792 )
793 { // Evaluate the next record
794 // delete current row in Keyset
795 if (m_pFileSet.is())
796 {
797 OSL_ENSURE(eCursorPosition == IResultSetHelper::NEXT, "Wrong CursorPosition!");
798 eCursorPosition = IResultSetHelper::NEXT;
799 nOffset = 1;
800 }
801 else if (eCursorPosition == IResultSetHelper::FIRST ||
802 eCursorPosition == IResultSetHelper::NEXT ||
803 eCursorPosition == IResultSetHelper::ABSOLUTE1)
804 {
805 eCursorPosition = IResultSetHelper::NEXT;
806 nOffset = 1;
807 }
808 else if (eCursorPosition == IResultSetHelper::LAST ||
809 eCursorPosition == IResultSetHelper::PRIOR)
810 {
811 eCursorPosition = IResultSetHelper::PRIOR;
812 nOffset = 1;
813 }
814 else if (eCursorPosition == IResultSetHelper::RELATIVE1)
815 {
816 eCursorPosition = (nOffset >= 0) ? IResultSetHelper::NEXT : IResultSetHelper::PRIOR;
817 }
818 else
819 {
820 return false;
821 }
822 // Try again ...
823 goto again;
824 }
825 }
826
827 // Evaluate may only be set,
828 // if the Keyset will be constructed further
829 if ( ( m_aSQLIterator.getStatementType() == OSQLStatementType::Select )
830 && !isCount()
831 && bEvaluate
832 )
833 {
834 if (m_pSortIndex)
835 {
836 std::unique_ptr<OKeyValue> pKeyValue = GetOrderbyKeyValue( m_aSelectRow );
837 m_pSortIndex->AddKeyValue(std::move(pKeyValue));
838 }
839 else if (m_pFileSet.is())
840 {
841 sal_uInt32 nBookmarkValue = std::abs(static_cast<sal_Int32>((*m_aEvaluateRow)[0]->getValue()));
842 m_pFileSet->push_back(nBookmarkValue);
843 }
844 }
845 else if (m_aSQLIterator.getStatementType() == OSQLStatementType::Update)
846 {
847 bool bOK = true;
848 if (bEvaluate)
849 {
850 // read the actual result-row
851 bOK = m_pTable->fetchRow(m_aEvaluateRow, *(m_pTable->getTableColumns()), true);
852 }
853
854 if (bOK)
855 {
856 // just give the values to be changed:
857 if(!m_pTable->UpdateRow(*m_aAssignValues,m_aEvaluateRow, m_xColsIdx))
858 return false;
859 }
860 }
861 else if (m_aSQLIterator.getStatementType() == OSQLStatementType::Delete)
862 {
863 bool bOK = true;
864 if (bEvaluate)
865 {
866 bOK = m_pTable->fetchRow(m_aEvaluateRow, *(m_pTable->getTableColumns()), true);
867 }
868 if (bOK)
869 {
870 if(!m_pTable->DeleteRow(*m_xColumns))
871 return false;
872 }
873 }
874 return true;
875 }
876
877
878 bool OResultSet::Move(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, bool bRetrieveData)
879 {
880 sal_Int32 nTempPos = m_nRowPos;
881
882 if (m_aSQLIterator.getStatementType() == OSQLStatementType::Select &&
883 !isCount())
884 {
885 if (!m_pFileSet.is()) //no Index available
886 {
887 // Normal FETCH
888 ExecuteRow(eCursorPosition,nOffset,false,bRetrieveData);
889
890 // now set the bookmark for outside this is the logical pos and not the file pos
891 *(*m_aRow->begin()) = sal_Int32(m_nRowPos + 1);
892 }
893 else
894 {
895 switch(eCursorPosition)
896 {
897 case IResultSetHelper::NEXT:
898 ++m_nRowPos;
899 break;
900 case IResultSetHelper::PRIOR:
901 if (m_nRowPos >= 0)
902 --m_nRowPos;
903 break;
904 case IResultSetHelper::FIRST:
905 m_nRowPos = 0;
906 break;
907 case IResultSetHelper::LAST:
908 m_nRowPos = m_pFileSet->size() - 1;
909 break;
910 case IResultSetHelper::RELATIVE1:
911 m_nRowPos += nOffset;
912 break;
913 case IResultSetHelper::ABSOLUTE1:
914 case IResultSetHelper::BOOKMARK:
915 if ( m_nRowPos == (nOffset -1) )
916 return true;
917 m_nRowPos = nOffset -1;
918 break;
919 }
920
921 // OffRange?
922 // The FileCursor is outside of the valid range, if:
923 // a.) m_nRowPos < 1
924 // b.) a KeySet exists and m_nRowPos > m_pFileSet->size()
925 if (m_nRowPos < 0 || (m_pFileSet->isFrozen() && eCursorPosition != IResultSetHelper::BOOKMARK && m_nRowPos >= static_cast<sal_Int32>(m_pFileSet->size()) )) // && m_pFileSet->IsFrozen()
926 {
927 goto Error;
928 }
929 else
930 {
931 if (m_nRowPos < static_cast<sal_Int32>(m_pFileSet->size()))
932 {
933 // Fetch via Index
934 bool bOK = ExecuteRow(IResultSetHelper::BOOKMARK,(*m_pFileSet)[m_nRowPos],false,bRetrieveData);
935 if (!bOK)
936 goto Error;
937
938 // now set the bookmark for outside
939 *(*m_aRow->begin()) = sal_Int32(m_nRowPos + 1);
940 if ( (bRetrieveData || m_pSQLAnalyzer->hasRestriction()) && m_pSQLAnalyzer->hasFunctions() )
941 {
942 m_pSQLAnalyzer->setSelectionEvaluationResult(m_aSelectRow,m_aColMapping);
943 }
944 }
945 else // Index must be further constructed
946 {
947 // set first on the last known row
948 if (m_pFileSet->empty())
949 {
950 m_pTable->seekRow(IResultSetHelper::ABSOLUTE1, 0, m_nFilePos);
951 }
952 else
953 {
954 m_aFileSetIter = m_pFileSet->end()-1;
955 m_pTable->seekRow(IResultSetHelper::BOOKMARK, *m_aFileSetIter, m_nFilePos);
956 }
957 bool bOK = true;
958 // Determine the number of further Fetches
959 while (bOK && m_nRowPos >= static_cast<sal_Int32>(m_pFileSet->size()))
960 {
961 bOK = ExecuteRow(IResultSetHelper::NEXT,1,true, false);//bRetrieveData);
962 }
963
964 if (bOK)
965 {
966 // read the results again
967 m_pTable->fetchRow(m_aRow, *(m_pTable->getTableColumns()), bRetrieveData);
968
969 // now set the bookmark for outside
970 *(*m_aRow->begin()) = sal_Int32(m_nRowPos + 1);
971
972 if ( (bRetrieveData || m_pSQLAnalyzer->hasRestriction()) && m_pSQLAnalyzer->hasFunctions() )
973 {
974 m_pSQLAnalyzer->setSelectionEvaluationResult(m_aSelectRow,m_aColMapping);
975 }
976 }
977 else if (!m_pFileSet->isFrozen()) // no valid record found
978 {
979 m_pFileSet->setFrozen();
980 goto Error;
981 }
982 }
983 }
984 }
985 }
986 else if (m_aSQLIterator.getStatementType() == OSQLStatementType::Select && isCount())
987 {
988 // Fetch the COUNT(*)
989 switch (eCursorPosition)
990 {
991 case IResultSetHelper::NEXT:
992 ++m_nRowPos;
993 break;
994 case IResultSetHelper::PRIOR:
995 --m_nRowPos;
996 break;
997 case IResultSetHelper::FIRST:
998 m_nRowPos = 0;
999 break;
1000 case IResultSetHelper::LAST:
1001 m_nRowPos = 0;
1002 break;
1003 case IResultSetHelper::RELATIVE1:
1004 m_nRowPos += nOffset;
1005 break;
1006 case IResultSetHelper::ABSOLUTE1:
1007 case IResultSetHelper::BOOKMARK:
1008 m_nRowPos = nOffset - 1;
1009 break;
1010 }
1011
1012 if ( m_nRowPos < 0 )
1013 goto Error;
1014 else if (m_nRowPos == 0)
1015 {
1016 // put COUNT(*) in result-row
1017 // (must be the first and only variable in the row)
1018 if (m_aRow->size() >= 2)
1019 {
1020 *(*m_aRow)[1] = m_nRowCountResult;
1021 *(*m_aRow)[0] = sal_Int32(1);
1022 (*m_aRow)[1]->setBound(true);
1023 (*m_aSelectRow)[1] = (*m_aRow)[1];
1024 }
1025 }
1026 else
1027 {
1028 m_nRowPos = 1;
1029 return false;
1030 }
1031 }
1032 else
1033 // Fetch only possible at SELECT!
1034 return false;
1035
1036 return true;
1037
1038 Error:
1039 // is the Cursor positioned before the first row
1040 // then the position will be maintained
1041 if (nTempPos == -1)
1042 m_nRowPos = nTempPos;
1043 else
1044 {
1045 switch(eCursorPosition)
1046 {
1047 case IResultSetHelper::PRIOR:
1048 case IResultSetHelper::FIRST:
1049 m_nRowPos = -1;
1050 break;
1051 case IResultSetHelper::LAST:
1052 case IResultSetHelper::NEXT:
1053 case IResultSetHelper::ABSOLUTE1:
1054 case IResultSetHelper::RELATIVE1:
1055 if (nOffset > 0)
1056 m_nRowPos = m_pFileSet.is() ? static_cast<sal_Int32>(m_pFileSet->size()) : -1;
1057 else if (nOffset < 0)
1058 m_nRowPos = -1;
1059 break;
1060 case IResultSetHelper::BOOKMARK:
1061 m_nRowPos = nTempPos; // last Position
1062 }
1063 }
1064 return false;
1065 }
1066
1067 void OResultSet::sortRows()
1068 {
1069 if (!m_pSQLAnalyzer->hasRestriction() && m_aOrderbyColumnNumber.size() == 1)
1070 {
1071 // is just one field given for sorting
1072 // and this field is indexed, then the Index will be used
1073 Reference<XIndexesSupplier> xIndexSup;
1074 m_pTable->queryInterface(cppu::UnoType<XIndexesSupplier>::get()) >>= xIndexSup;
1075
1076 Reference<XIndexAccess> xIndexes;
1077 if(xIndexSup.is())
1078 {
1079 xIndexes.set(xIndexSup->getIndexes(),UNO_QUERY);
1080 Reference<XPropertySet> xColProp;
1081 if(m_aOrderbyColumnNumber[0] < xIndexes->getCount())
1082 {
1083 xColProp.set(xIndexes->getByIndex(m_aOrderbyColumnNumber[0]),UNO_QUERY);
1084 // iterate through the indexes to find the matching column
1085 const sal_Int32 nCount = xIndexes->getCount();
1086 for(sal_Int32 i=0; i < nCount;++i)
1087 {
1088 Reference<XColumnsSupplier> xIndex(xIndexes->getByIndex(i),UNO_QUERY);
1089 Reference<XNameAccess> xIndexCols = xIndex->getColumns();
1090 if(xIndexCols->hasByName(comphelper::getString(xColProp->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)))))
1091 {
1092 m_pFileSet = new OKeySet();
1093
1094 if(fillIndexValues(xIndex))
1095 return;
1096 }
1097 }
1098 }
1099 }
1100 }
1101
1102 OSortIndex::TKeyTypeVector eKeyType(m_aOrderbyColumnNumber.size());
1103 size_t i = 0;
1104 for (auto const& elem : m_aOrderbyColumnNumber)
1105 {
1106 OSL_ENSURE(static_cast<sal_Int32>(m_aSelectRow->size()) > elem,"Invalid Index");
1107 switch ((*(m_aSelectRow->begin()+elem))->getValue().getTypeKind())
1108 {
1109 case DataType::CHAR:
1110 case DataType::VARCHAR:
1111 case DataType::LONGVARCHAR:
1112 eKeyType[i] = OKeyType::String;
1113 break;
1114
1115 case DataType::OTHER:
1116 case DataType::TINYINT:
1117 case DataType::SMALLINT:
1118 case DataType::INTEGER:
1119 case DataType::DECIMAL:
1120 case DataType::NUMERIC:
1121 case DataType::REAL:
1122 case DataType::DOUBLE:
1123 case DataType::DATE:
1124 case DataType::TIME:
1125 case DataType::TIMESTAMP:
1126 case DataType::BIT:
1127 eKeyType[i] = OKeyType::Double;
1128 break;
1129
1130 // Other types aren't implemented (so they are always FALSE)
1131 default:
1132 eKeyType[i] = OKeyType::NONE;
1133 SAL_WARN( "connectivity.drivers","OFILECursor::Execute: Data type not implemented");
1134 break;
1135 }
1136 (*m_aSelectRow)[elem]->setBound(true);
1137 ++i;
1138 }
1139
1140 m_pSortIndex.reset(new OSortIndex(eKeyType,m_aOrderbyAscending));
1141
1142 while ( ExecuteRow( IResultSetHelper::NEXT, 1, false ) )
1143 {
1144 (*m_aSelectRow)[0]->setValue( (*m_aRow)[0]->getValue() );
1145 if ( m_pSQLAnalyzer->hasFunctions() )
1146 m_pSQLAnalyzer->setSelectionEvaluationResult( m_aSelectRow, m_aColMapping );
1147 const sal_Int32 nBookmark = (*m_aRow->begin())->getValue();
1148 ExecuteRow( IResultSetHelper::BOOKMARK, nBookmark, true, false );
1149 }
1150
1151 // create sorted Keyset
1152 m_pFileSet = nullptr;
1153 m_pFileSet = m_pSortIndex->CreateKeySet();
1154 m_pSortIndex.reset();
1155 // now access to a sorted set is possible via Index
1156 }
1157
1158
1159 void OResultSet::OpenImpl()
1160 {
1161 OSL_ENSURE(m_pSQLAnalyzer,"No analyzer set with setSqlAnalyzer!");
1162 if(!m_pTable.is())
1163 {
1164 const OSQLTables& rTabs = m_aSQLIterator.getTables();
1165 if (rTabs.empty() || !rTabs.begin()->second.is())
1166 lcl_throwError(STR_QUERY_TOO_COMPLEX,*this);
1167
1168 if ( rTabs.size() > 1 || m_aSQLIterator.hasErrors() )
1169 lcl_throwError(STR_QUERY_MORE_TABLES,*this);
1170
1171 OSQLTable xTable = rTabs.begin()->second;
1172 m_xColumns = m_aSQLIterator.getSelectColumns();
1173
1174 m_xColNames = xTable->getColumns();
1175 m_xColsIdx.set(m_xColNames,UNO_QUERY);
1176 doTableSpecials(xTable);
1177 Reference<XComponent> xComp(xTable,UNO_QUERY);
1178 if(xComp.is())
1179 xComp->addEventListener(this);
1180 }
1181
1182 m_pTable->refreshHeader();
1183
1184 sal_Int32 nColumnCount = m_xColsIdx->getCount();
1185
1186 initializeRow(m_aRow,nColumnCount);
1187 initializeRow(m_aEvaluateRow,nColumnCount);
1188 initializeRow(m_aInsertRow,nColumnCount);
1189
1190
1191 m_nResultSetConcurrency = (m_pTable->isReadOnly() || isCount()) ? ResultSetConcurrency::READ_ONLY : ResultSetConcurrency::UPDATABLE;
1192
1193 // create new Index:
1194 m_pFileSet = nullptr;
1195
1196 // position at the beginning
1197 m_nRowPos = -1;
1198 m_nFilePos = 0;
1199 m_nRowCountResult = -1;
1200 m_pTable->seekRow(IResultSetHelper::ABSOLUTE1, 0, m_nFilePos);
1201
1202 m_nLastVisitedPos = m_pTable->getCurrentLastPos();
1203
1204 switch(m_aSQLIterator.getStatementType())
1205 {
1206 case OSQLStatementType::Select:
1207 {
1208 if(isCount())
1209 {
1210 if(m_xColumns->size() > 1)
1211 lcl_throwError(STR_QUERY_COMPLEX_COUNT,*this);
1212
1213 m_nRowCountResult = 0;
1214 // for now simply iterate over all rows and
1215 // do all actions (or just count)
1216 {
1217 bool bOK = true;
1218 while (bOK)
1219 {
1220 bOK = ExecuteRow(IResultSetHelper::NEXT);
1221
1222 if (bOK)
1223 {
1224 m_nRowCountResult++;
1225 }
1226 }
1227
1228 // save result of COUNT(*) in m_nRowCountResult.
1229 // nRowCount (number of Rows in the result) = 1 for this request!
1230 }
1231 }
1232 else
1233 {
1234 bool bDistinct = false;
1235 assert(m_pParseTree != nullptr);
1236 OSQLParseNode *pDistinct = m_pParseTree->getChild(1);
1237
1238 assert(m_aOrderbyColumnNumber.size() ==
1239 m_aOrderbyAscending.size());
1240 if (pDistinct && pDistinct->getTokenID() == SQL_TOKEN_DISTINCT )
1241 {
1242 // To eliminate duplicates we need to sort on all columns.
1243 // This is not a problem because the SQL spec says that the
1244 // order of columns that are not specified in ORDER BY
1245 // clause is undefined, so it doesn't hurt to sort on
1246 // these; pad the vectors to include them.
1247 for (size_t i = 1; // 0: bookmark (see setBoundedColumns)
1248 i < m_aColMapping.size(); ++i)
1249 {
1250 if (std::find(m_aOrderbyColumnNumber.begin(),
1251 m_aOrderbyColumnNumber.end(),
1252 sal::static_int_cast<sal_Int32>(i))
1253 == m_aOrderbyColumnNumber.end())
1254 {
1255 m_aOrderbyColumnNumber.push_back(i);
1256 // ASC or DESC doesn't matter
1257 m_aOrderbyAscending.push_back(TAscendingOrder::ASC);
1258 }
1259 }
1260 bDistinct = true;
1261 }
1262
1263 if (IsSorted())
1264 sortRows();
1265
1266 if (!m_pFileSet.is())
1267 {
1268 m_pFileSet = new OKeySet();
1269
1270 if (!m_pSQLAnalyzer->hasRestriction())
1271 // now the Keyset can be filled!
1272 // But be careful: It is assumed, that the FilePositions will be stored as sequence 1..n
1273 {
1274 if ( m_nLastVisitedPos > 0)
1275 m_pFileSet->reserve( m_nLastVisitedPos );
1276 for (sal_Int32 i = 0; i < m_nLastVisitedPos; i++)
1277 m_pFileSet->push_back(i + 1);
1278 }
1279 }
1280 OSL_ENSURE(m_pFileSet.is(),"No KeySet existing! :-(");
1281
1282 if(bDistinct && m_pFileSet.is())
1283 {
1284 OValueRow aSearchRow = new OValueVector(m_aRow->size());
1285 OValueRefVector::iterator aRowIter = m_aRow->begin();
1286 OValueVector::iterator aSearchIter = aSearchRow->begin();
1287 for ( ++aRowIter,++aSearchIter; // the first column is the bookmark column
1288 aRowIter != m_aRow->end();
1289 ++aRowIter,++aSearchIter)
1290 aSearchIter->setBound((*aRowIter)->isBound());
1291
1292 size_t nMaxRow = m_pFileSet->size();
1293
1294 if (nMaxRow)
1295 {
1296 #if OSL_DEBUG_LEVEL > 1
1297 sal_Int32 nFound=0;
1298 #endif
1299 sal_Int32 nPos;
1300 sal_Int32 nKey;
1301
1302 for( size_t j = nMaxRow-1; j > 0; --j)
1303 {
1304 nPos = (*m_pFileSet)[j];
1305 ExecuteRow(IResultSetHelper::BOOKMARK,nPos,false);
1306 m_pSQLAnalyzer->setSelectionEvaluationResult(m_aSelectRow,m_aColMapping);
1307 { // cop*y row values
1308 OValueRefVector::iterator copyFrom = m_aSelectRow->begin();
1309 OValueVector::iterator copyTo = aSearchRow->begin();
1310 for ( ++copyFrom,++copyTo; // the first column is the bookmark column
1311 copyFrom != m_aSelectRow->end();
1312 ++copyFrom,++copyTo)
1313 *copyTo = *(*copyFrom);
1314 }
1315
1316 // compare with next row
1317 nKey = (*m_pFileSet)[j-1];
1318 ExecuteRow(IResultSetHelper::BOOKMARK,nKey,false);
1319 m_pSQLAnalyzer->setSelectionEvaluationResult(m_aSelectRow,m_aColMapping);
1320 auto rowsMismatchIters = std::mismatch(std::next(m_aSelectRow->begin()), m_aSelectRow->end(),
1321 std::next(aSearchRow->begin()), // the first column is the bookmark column
1322 [](const OValueRefVector::value_type& a, const OValueVector::value_type& b) {
1323 return !a->isBound() || (*a == b); });
1324
1325 if(rowsMismatchIters.first == m_aSelectRow->end())
1326 (*m_pFileSet)[j] = 0; // Rows match -- Mark for deletion by setting key to 0
1327 #if OSL_DEBUG_LEVEL > 1
1328 else
1329 nFound++;
1330 #endif
1331 }
1332
1333 m_pFileSet->erase(std::remove(m_pFileSet->begin(),m_pFileSet->end(),0)
1334 ,m_pFileSet->end());
1335 }
1336 }
1337 }
1338 } break;
1339
1340 case OSQLStatementType::Update:
1341 case OSQLStatementType::Delete:
1342 // during processing count the number of processed Rows
1343 m_nRowCountResult = 0;
1344 // for now simply iterate over all rows and
1345 // run the actions (or simply count):
1346 {
1347
1348 bool bOK = true;
1349 while (bOK)
1350 {
1351 bOK = ExecuteRow(IResultSetHelper::NEXT);
1352
1353 if (bOK)
1354 {
1355 m_nRowCountResult++;
1356 }
1357 }
1358
1359 // save result of COUNT(*) in nRowCountResult.
1360 // nRowCount (number of rows in the result-set) = 1 for this request!
1361 }
1362 break;
1363 case OSQLStatementType::Insert:
1364 m_nRowCountResult = 0;
1365
1366 OSL_ENSURE(m_aAssignValues.is(),"No assign values set!");
1367 if(!m_pTable->InsertRow(*m_aAssignValues, m_xColsIdx))
1368 {
1369 m_nFilePos = 0;
1370 return;
1371 }
1372
1373 m_nRowCountResult = 1;
1374 break;
1375 default:
1376 SAL_WARN( "connectivity.drivers", "OResultSet::OpenImpl: unsupported statement type!" );
1377 break;
1378 }
1379
1380 // reset FilePos
1381 m_nFilePos = 0;
1382 }
1383
1384 Sequence< sal_Int8 > OResultSet::getUnoTunnelId()
1385 {
1386 static ::cppu::OImplementationId implId;
1387
1388 return implId.getImplementationId();
1389 }
1390
1391 // css::lang::XUnoTunnel
1392
1393 sal_Int64 OResultSet::getSomething( const Sequence< sal_Int8 > & rId )
1394 {
1395 return isUnoTunnelId<OResultSet>(rId)
1396 ? reinterpret_cast< sal_Int64 >( this )
1397 : 0;
1398 }
1399
1400 void OResultSet::setBoundedColumns(const OValueRefRow& _rRow,
1401 const OValueRefRow& _rSelectRow,
1402 const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns,
1403 const Reference<XIndexAccess>& _xNames,
1404 bool _bSetColumnMapping,
1405 const Reference<XDatabaseMetaData>& _xMetaData,
1406 std::vector<sal_Int32>& _rColMapping)
1407 {
1408 ::comphelper::UStringMixEqual aCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
1409
1410 Reference<XPropertySet> xTableColumn;
1411 OUString sTableColumnName, sSelectColumnRealName;
1412
1413 const OUString sName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
1414 const OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME);
1415 const OUString sType = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE);
1416
1417 std::map<OSQLColumns::iterator,bool> aSelectIters;
1418 OValueRefVector::const_iterator aRowIter = _rRow->begin()+1;
1419 for (sal_Int32 i=0; // the first column is the bookmark column
1420 aRowIter != _rRow->end();
1421 ++i, ++aRowIter
1422 )
1423 {
1424 (*aRowIter)->setBound(false);
1425 try
1426 {
1427 // get the table column and its name
1428 _xNames->getByIndex(i) >>= xTableColumn;
1429 OSL_ENSURE(xTableColumn.is(), "OResultSet::setBoundedColumns: invalid table column!");
1430 if (xTableColumn.is())
1431 xTableColumn->getPropertyValue(sName) >>= sTableColumnName;
1432 else
1433 sTableColumnName.clear();
1434
1435 // look if we have such a select column
1436 // TODO: would like to have a O(log n) search here ...
1437 for ( OSQLColumns::iterator aIter = _rxColumns->begin();
1438 aIter != _rxColumns->end();
1439 ++aIter
1440 )
1441 {
1442 if((*aIter)->getPropertySetInfo()->hasPropertyByName(sRealName))
1443 (*aIter)->getPropertyValue(sRealName) >>= sSelectColumnRealName;
1444 else
1445 (*aIter)->getPropertyValue(sName) >>= sSelectColumnRealName;
1446
1447 if ( aCase(sTableColumnName, sSelectColumnRealName) && !(*aRowIter)->isBound() && aSelectIters.end() == aSelectIters.find(aIter) )
1448 {
1449 aSelectIters.emplace(aIter,true);
1450 if(_bSetColumnMapping)
1451 {
1452 sal_Int32 nSelectColumnPos = aIter - _rxColumns->begin() + 1;
1453 // the getXXX methods are 1-based ...
1454 sal_Int32 nTableColumnPos = i + 1;
1455 // get first table column is the bookmark column ...
1456 _rColMapping[nSelectColumnPos] = nTableColumnPos;
1457 (*_rSelectRow)[nSelectColumnPos] = *aRowIter;
1458 }
1459
1460 (*aRowIter)->setBound(true);
1461 sal_Int32 nType = DataType::OTHER;
1462 if (xTableColumn.is())
1463 xTableColumn->getPropertyValue(sType) >>= nType;
1464 (*aRowIter)->setTypeKind(nType);
1465
1466 break;
1467 }
1468 }
1469 }
1470 catch (Exception&)
1471 {
1472 TOOLS_WARN_EXCEPTION( "connectivity.drivers","");
1473 }
1474 }
1475 // in this case we got more select columns as columns exist in the table
1476 if ( !(_bSetColumnMapping && aSelectIters.size() != _rColMapping.size()) )
1477 return;
1478
1479 Reference<XNameAccess> xNameAccess(_xNames,UNO_QUERY);
1480 Sequence< OUString > aSelectColumns = xNameAccess->getElementNames();
1481
1482 for ( OSQLColumns::iterator aIter = _rxColumns->begin();
1483 aIter != _rxColumns->end();
1484 ++aIter
1485 )
1486 {
1487 if ( aSelectIters.end() == aSelectIters.find(aIter) )
1488 {
1489 if ( (*aIter)->getPropertySetInfo()->hasPropertyByName(sRealName) )
1490 (*aIter)->getPropertyValue(sRealName) >>= sSelectColumnRealName;
1491 else
1492 (*aIter)->getPropertyValue(sName) >>= sSelectColumnRealName;
1493
1494 if ( xNameAccess->hasByName( sSelectColumnRealName ) )
1495 {
1496 aSelectIters.emplace(aIter,true);
1497 sal_Int32 nSelectColumnPos = aIter - _rxColumns->begin() + 1;
1498 const OUString* pBegin = aSelectColumns.getConstArray();
1499 const OUString* pEnd = pBegin + aSelectColumns.getLength();
1500 for(sal_Int32 i=0;pBegin != pEnd;++pBegin,++i)
1501 {
1502 if ( aCase(*pBegin, sSelectColumnRealName) )
1503 {
1504 // the getXXX methods are 1-based ...
1505 sal_Int32 nTableColumnPos = i + 1;
1506 // get first table column is the bookmark column ...
1507 _rColMapping[nSelectColumnPos] = nTableColumnPos;
1508 (*_rSelectRow)[nSelectColumnPos] = (*_rRow)[nTableColumnPos];
1509 break;
1510 }
1511 }
1512 }
1513 }
1514 }
1515 }
1516
1517 void SAL_CALL OResultSet::acquire() throw()
1518 {
1519 OResultSet_BASE::acquire();
1520 }
1521
1522 void SAL_CALL OResultSet::release() throw()
1523 {
1524 OResultSet_BASE::release();
1525 }
1526
1527 Reference< css::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo( )
1528 {
1529 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
1530 }
1531
1532 void OResultSet::doTableSpecials(const OSQLTable& _xTable)
1533 {
1534 Reference<css::lang::XUnoTunnel> xTunnel(_xTable, UNO_QUERY_THROW);
1535 m_pTable = reinterpret_cast< OFileTable* >(xTunnel->getSomething(OFileTable::getUnoTunnelId()));
1536 assert(m_pTable.is());
1537 }
1538
1539 void OResultSet::clearInsertRow()
1540 {
1541 m_aRow->setDeleted(false); // set to false here because this is the new row
1542 sal_Int32 nPos = 0;
1543 for(ORowSetValueDecoratorRef& rValue : *m_aInsertRow)
1544 {
1545 if ( rValue->isBound() )
1546 {
1547 (*m_aRow)[nPos]->setValue( rValue->getValue() );
1548 }
1549 rValue->setBound(nPos == 0);
1550 rValue->setModified(false);
1551 rValue->setNull();
1552 ++nPos;
1553 }
1554 }
1555
1556 void OResultSet::initializeRow(OValueRefRow& _rRow,sal_Int32 _nColumnCount)
1557 {
1558 if(!_rRow.is())
1559 {
1560 _rRow = new OValueRefVector(_nColumnCount);
1561 (*_rRow)[0]->setBound(true);
1562 std::for_each(_rRow->begin()+1,_rRow->end(),TSetRefBound(false));
1563 }
1564 }
1565
1566 bool OResultSet::fillIndexValues(const Reference< XColumnsSupplier> &/*_xIndex*/)
1567 {
1568 return false;
1569 }
1570
1571 bool OResultSet::move(IResultSetHelper::Movement _eCursorPosition, sal_Int32 _nOffset, bool _bRetrieveData)
1572 {
1573 return Move(_eCursorPosition,_nOffset,_bRetrieveData);
1574 }
1575
1576 sal_Int32 OResultSet::getDriverPos() const
1577 {
1578 return (*m_aRow)[0]->getValue();
1579 }
1580
1581 bool OResultSet::isRowDeleted() const
1582 {
1583 return m_aRow->isDeleted();
1584 }
1585
1586 void SAL_CALL OResultSet::disposing( const EventObject& Source )
1587 {
1588 Reference<XPropertySet> xProp = m_pTable.get();
1589 if(m_pTable.is() && Source.Source == xProp)
1590 {
1591 m_pTable.clear();
1592 }
1593 }
1594
1595
1596 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE